From 7583a4d4eb9feadf45c20b45710e0cd9adc7c2e6 Mon Sep 17 00:00:00 2001
From: Arpit Temani <temaniarpit27@gmail.com>
Date: Tue, 18 Oct 2022 20:53:58 +0530
Subject: [PATCH 01/96] lock, unlock to rlock, runlock

---
 core/tx_pool.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 7648668688..0cc109ee24 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -542,8 +542,8 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 // transactions and only return those whose **effective** tip is large enough in
 // the next pending execution environment.
 func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transactions {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
+	pool.mu.RLock()
+	defer pool.mu.RUnlock()
 
 	pending := make(map[common.Address]types.Transactions)
 	for addr, list := range pool.pending {
@@ -567,8 +567,8 @@ func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transacti
 
 // Locals retrieves the accounts currently considered local by the pool.
 func (pool *TxPool) Locals() []common.Address {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
+	pool.mu.RLock()
+	defer pool.mu.RUnlock()
 
 	return pool.locals.flatten()
 }

From f6d0296d0ce5e8d2a9d4399fcf1747f39bd20bc4 Mon Sep 17 00:00:00 2001
From: Shivam Sharma <shivam691999@gmail.com>
Date: Tue, 18 Oct 2022 21:52:16 +0530
Subject: [PATCH 02/96] add : tracing Pending() and Locals()

---
 miner/worker.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/miner/worker.go b/miner/worker.go
index 797e7ea980..bd5b6ff58e 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1135,9 +1135,14 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 	)
 
 	tracing.Exec(ctx, "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
+
+		prePendingTime := time.Now()
+
 		pending := w.eth.TxPool().Pending(true)
 		remoteTxs = pending
 
+		postPendingTime := time.Now()
+
 		for _, account := range w.eth.TxPool().Locals() {
 			if txs := remoteTxs[account]; len(txs) > 0 {
 				delete(remoteTxs, account)
@@ -1145,6 +1150,8 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			}
 		}
 
+		postLocalsTime := time.Now()
+
 		localTxsCount = len(localTxs)
 		remoteTxsCount = len(remoteTxs)
 
@@ -1152,6 +1159,8 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			span,
 			attribute.Int("len of local txs", localTxsCount),
 			attribute.Int("len of remote txs", remoteTxsCount),
+			attribute.String("time taken by Pending()", fmt.Sprintf("%v", postPendingTime.Sub(prePendingTime))),
+			attribute.String("time taken by Locals()", fmt.Sprintf("%v", postLocalsTime.Sub(postPendingTime))),
 		)
 	})
 

From dc0c2a3601dbb73bf967ff3a75c8257bdfad14ec Mon Sep 17 00:00:00 2001
From: Jerry <jerrycgh@gmail.com>
Date: Tue, 18 Oct 2022 12:01:12 -0700
Subject: [PATCH 03/96] Log time spent in committing a tx during mining

---
 miner/worker.go | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/miner/worker.go b/miner/worker.go
index bd5b6ff58e..e4feeb5fc8 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -965,7 +965,14 @@ func (w *worker) commitTransactions(env *environment, txs *types.TransactionsByP
 		// Start executing the transaction
 		env.state.Prepare(tx.Hash(), env.tcount)
 
+		log.Info("Commit new tx", "tx hash", tx.Hash(), "from", from, "to", tx.To(), "nonce", tx.Nonce(), "gas", tx.Gas(), "gasPrice", tx.GasPrice(), "value", tx.Value(), "data", tx.Data())
+
+		start := time.Now()
+
 		logs, err := w.commitTransaction(env, tx)
+
+		log.Info("Finished committing tx", "tx hash", tx.Hash(), "time spent", time.Since(start))
+
 		switch {
 		case errors.Is(err, core.ErrGasLimitReached):
 			// Pop the current out-of-gas transaction without shifting in the next from the account

From 02bc70406bc04664e86891f4f4307363f5438f88 Mon Sep 17 00:00:00 2001
From: Jerry <jerrycgh@gmail.com>
Date: Tue, 18 Oct 2022 12:18:01 -0700
Subject: [PATCH 04/96] Remove data from logging

---
 miner/worker.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/miner/worker.go b/miner/worker.go
index e4feeb5fc8..f4f46b0941 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -965,7 +965,7 @@ func (w *worker) commitTransactions(env *environment, txs *types.TransactionsByP
 		// Start executing the transaction
 		env.state.Prepare(tx.Hash(), env.tcount)
 
-		log.Info("Commit new tx", "tx hash", tx.Hash(), "from", from, "to", tx.To(), "nonce", tx.Nonce(), "gas", tx.Gas(), "gasPrice", tx.GasPrice(), "value", tx.Value(), "data", tx.Data())
+		log.Info("Commit new tx", "tx hash", tx.Hash(), "from", from, "to", tx.To(), "nonce", tx.Nonce(), "gas", tx.Gas(), "gasPrice", tx.GasPrice(), "value", tx.Value())
 
 		start := time.Now()
 

From a42682eddeb20df9eb8a43becb0cf42b3ad70ba7 Mon Sep 17 00:00:00 2001
From: Jerry <jerrycgh@gmail.com>
Date: Tue, 18 Oct 2022 12:24:58 -0700
Subject: [PATCH 05/96] Move log into case where a tx completes without error

---
 miner/worker.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index f4f46b0941..5aa0aced61 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -965,14 +965,10 @@ func (w *worker) commitTransactions(env *environment, txs *types.TransactionsByP
 		// Start executing the transaction
 		env.state.Prepare(tx.Hash(), env.tcount)
 
-		log.Info("Commit new tx", "tx hash", tx.Hash(), "from", from, "to", tx.To(), "nonce", tx.Nonce(), "gas", tx.Gas(), "gasPrice", tx.GasPrice(), "value", tx.Value())
-
 		start := time.Now()
 
 		logs, err := w.commitTransaction(env, tx)
 
-		log.Info("Finished committing tx", "tx hash", tx.Hash(), "time spent", time.Since(start))
-
 		switch {
 		case errors.Is(err, core.ErrGasLimitReached):
 			// Pop the current out-of-gas transaction without shifting in the next from the account
@@ -994,6 +990,7 @@ func (w *worker) commitTransactions(env *environment, txs *types.TransactionsByP
 			coalescedLogs = append(coalescedLogs, logs...)
 			env.tcount++
 			txs.Shift()
+			log.Info("Committed new tx", "tx hash", tx.Hash(), "from", from, "to", tx.To(), "nonce", tx.Nonce(), "gas", tx.Gas(), "gasPrice", tx.GasPrice(), "value", tx.Value(), "time spent", time.Since(start))
 
 		case errors.Is(err, core.ErrTxTypeNotSupported):
 			// Pop the unsupported transaction without shifting in the next from the account

From 5d1196ada2c421ca01e2314fa5330ec511c53c8a Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Tue, 18 Oct 2022 21:52:09 +0530
Subject: [PATCH 06/96] profile fillTransactions

---
 miner/worker.go | 64 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/miner/worker.go b/miner/worker.go
index 5aa0aced61..245d6b4464 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -21,6 +21,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"os"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -41,6 +42,8 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
+
+	"github.com/ethereum/go-ethereum/internal/cli/server/pprof"
 )
 
 const (
@@ -257,6 +260,8 @@ type worker struct {
 	skipSealHook func(*task) bool                   // Method to decide whether skipping the sealing.
 	fullTaskHook func()                             // Method to call before pushing the full sealing task.
 	resubmitHook func(time.Duration, time.Duration) // Method to call upon updating resubmitting interval.
+
+	profileCount int32 // Global count for profiling
 }
 
 //nolint:staticcheck
@@ -1121,6 +1126,34 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) {
 	return env, nil
 }
 
+func startProfiler(profile string, filename string) {
+	ctx := context.Background()
+
+	var (
+		payload []byte
+		err     error
+	)
+
+	switch profile {
+	case "cpu":
+		payload, _, err = pprof.CPUProfile(ctx, 10)
+
+	case "trace":
+		payload, _, err = pprof.Trace(ctx, 10)
+
+	case "heap":
+		// TODO
+
+	default:
+		log.Info("Incorrect profile name")
+	}
+
+	if len(payload) != 0 && err != nil {
+		os.WriteFile(filename, payload, 0644)
+	}
+
+}
+
 // fillTransactions retrieves the pending transactions from the txpool and fills them
 // into the given sealing block. The transaction selection and ordering strategy can
 // be customized with the plugin in the future.
@@ -1136,8 +1169,39 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		remoteTxsCount int
 		localTxs       = make(map[common.Address]types.Transactions)
 		remoteTxs      map[common.Address]types.Transactions
+		done           chan struct{}
 	)
 
+	go func() {
+		select {
+		case <-time.After(300 * time.Millisecond):
+			// Check if we've not crossed limit
+			if atomic.LoadInt32(&w.profileCount) > 100 {
+				return
+			}
+
+			log.Info("Starting profiling in fillTransactions")
+
+			// create temp dir
+			name := "./traces/" + time.Now().UTC().Format("2006-01-02-150405Z")
+			err := os.MkdirAll(name, 0755)
+			if err != nil {
+				return
+			}
+
+			// grab the cpu profile
+			startProfiler("cpu", name+"cpu.prof")
+			atomic.AddInt32(&w.profileCount, 1)
+
+		case <-done:
+			// Do nothing
+		}
+	}()
+
+	defer func() {
+		close(done)
+	}()
+
 	tracing.Exec(ctx, "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 
 		prePendingTime := time.Now()

From a734bb69ad9838b5733d97bc25f8229686d49a86 Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Tue, 18 Oct 2022 21:57:00 +0530
Subject: [PATCH 07/96] fix conflict

---
 miner/worker.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index 245d6b4464..d153779700 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1198,10 +1198,6 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		}
 	}()
 
-	defer func() {
-		close(done)
-	}()
-
 	tracing.Exec(ctx, "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 
 		prePendingTime := time.Now()
@@ -1219,6 +1215,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		}
 
 		postLocalsTime := time.Now()
+		close(done)
 
 		localTxsCount = len(localTxs)
 		remoteTxsCount = len(remoteTxs)

From b8ea548724d7cce6556936e0ebf41ae1af103766 Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Wed, 19 Oct 2022 01:19:09 +0530
Subject: [PATCH 08/96] bug fixes

---
 internal/cli/server/pprof/pprof.go | 22 +++++++++++++++++
 miner/worker.go                    | 38 +++++++++++++++++-------------
 2 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/internal/cli/server/pprof/pprof.go b/internal/cli/server/pprof/pprof.go
index 44034f3bb8..69056bd0fb 100644
--- a/internal/cli/server/pprof/pprof.go
+++ b/internal/cli/server/pprof/pprof.go
@@ -61,6 +61,28 @@ func CPUProfile(ctx context.Context, sec int) ([]byte, map[string]string, error)
 		}, nil
 }
 
+// CPUProfile generates a CPU Profile for a given duration
+func CPUProfileWithChannel(done chan bool) ([]byte, map[string]string, error) {
+	var buf bytes.Buffer
+	if err := pprof.StartCPUProfile(&buf); err != nil {
+		return nil, nil, err
+	}
+
+	select {
+	case <-done:
+	case <-time.After(30 * time.Second):
+	}
+
+	pprof.StopCPUProfile()
+
+	return buf.Bytes(),
+		map[string]string{
+			"X-Content-Type-Options": "nosniff",
+			"Content-Type":           "application/octet-stream",
+			"Content-Disposition":    `attachment; filename="profile"`,
+		}, nil
+}
+
 // Trace runs a trace profile for a given duration
 func Trace(ctx context.Context, sec int) ([]byte, map[string]string, error) {
 	if sec <= 0 {
diff --git a/miner/worker.go b/miner/worker.go
index d153779700..264e27e4da 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1126,7 +1126,7 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) {
 	return env, nil
 }
 
-func startProfiler(profile string, filename string) {
+func startProfiler(profile string, filepath string) error {
 	ctx := context.Background()
 
 	var (
@@ -1148,10 +1148,20 @@ func startProfiler(profile string, filename string) {
 		log.Info("Incorrect profile name")
 	}
 
-	if len(payload) != 0 && err != nil {
-		os.WriteFile(filename, payload, 0644)
+	if err != nil {
+		return err
+	}
+
+	if len(payload) != 0 && err == nil {
+		err := os.MkdirAll(filepath, 0755)
+		if err != nil {
+			return err
+		}
+		err = os.WriteFile(filepath+"/"+profile+".prof", payload, 0644)
+		return err
 	}
 
+	return nil
 }
 
 // fillTransactions retrieves the pending transactions from the txpool and fills them
@@ -1169,34 +1179,30 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		remoteTxsCount int
 		localTxs       = make(map[common.Address]types.Transactions)
 		remoteTxs      map[common.Address]types.Transactions
-		done           chan struct{}
+		done           chan struct{} = make(chan struct{})
 	)
 
-	go func() {
+	go func(done chan struct{}, number uint64) {
 		select {
 		case <-time.After(300 * time.Millisecond):
 			// Check if we've not crossed limit
-			if atomic.LoadInt32(&w.profileCount) > 100 {
+			if atomic.LoadInt32(&w.profileCount) >= 10 {
 				return
 			}
 
-			log.Info("Starting profiling in fillTransactions")
+			log.Info("Starting profiling in fill transactions", "number", number)
 
-			// create temp dir
-			name := "./traces/" + time.Now().UTC().Format("2006-01-02-150405Z")
-			err := os.MkdirAll(name, 0755)
-			if err != nil {
-				return
-			}
+			dir := "./traces/" + time.Now().UTC().Format("2006-01-02-150405Z")
 
 			// grab the cpu profile
-			startProfiler("cpu", name+"cpu.prof")
-			atomic.AddInt32(&w.profileCount, 1)
+			if err := startProfiler("cpu", dir); err == nil {
+				atomic.AddInt32(&w.profileCount, 1)
+			}
 
 		case <-done:
 			// Do nothing
 		}
-	}()
+	}(done, env.header.Number.Uint64())
 
 	tracing.Exec(ctx, "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 

From 434a34a161fc6398f2421bab5d51ab086dba0456 Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Wed, 19 Oct 2022 10:29:01 +0530
Subject: [PATCH 09/96] add logs

---
 miner/worker.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/miner/worker.go b/miner/worker.go
index 264e27e4da..0014acb8b7 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1196,6 +1196,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 
 			// grab the cpu profile
 			if err := startProfiler("cpu", dir); err == nil {
+				log.Info("Completed profiling", "path", dir, "number", number)
 				atomic.AddInt32(&w.profileCount, 1)
 			}
 

From 6c52e18f575dc06a8b7bcaccfc0d4c342e538a2a Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Wed, 19 Oct 2022 12:43:03 +0530
Subject: [PATCH 10/96] txpool: add tracing in Pending()

---
 core/tx_pool.go      | 23 ++++++++++++++++++++---
 core/tx_pool_test.go |  4 ++--
 eth/api_backend.go   |  2 +-
 eth/handler.go       |  3 ++-
 eth/handler_test.go  |  3 ++-
 eth/sync.go          |  3 ++-
 miner/worker.go      |  2 +-
 7 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 0cc109ee24..37804d90f7 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -17,7 +17,9 @@
 package core
 
 import (
+	"context"
 	"errors"
+	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -27,6 +29,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/prque"
+	"github.com/ethereum/go-ethereum/common/tracing"
 	"github.com/ethereum/go-ethereum/consensus/misc"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -34,6 +37,8 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/params"
+
+	"go.opentelemetry.io/otel/trace"
 )
 
 const (
@@ -541,13 +546,24 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 // The enforceTips parameter can be used to do an extra filtering on the pending
 // transactions and only return those whose **effective** tip is large enough in
 // the next pending execution environment.
-func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transactions {
-	pool.mu.RLock()
+func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Address]types.Transactions {
+	ctx, span := tracing.StartSpan(ctx, "txpool.Pending()")
+	defer tracing.EndSpan(span)
+
+	tracing.ElapsedTime(ctx, span, "txpool.Pending.RLock() time taken", func(ctx context.Context, s trace.Span) {
+		pool.mu.RLock()
+	})
+
 	defer pool.mu.RUnlock()
 
 	pending := make(map[common.Address]types.Transactions)
 	for addr, list := range pool.pending {
-		txs := list.Flatten()
+		msg := "Flatten - " + addr.String() + " - " + fmt.Sprint(list.Len())
+
+		var txs types.Transactions
+		tracing.ElapsedTime(ctx, span, msg, func(ctx context.Context, s trace.Span) {
+			txs = list.Flatten()
+		})
 
 		// If the miner requests tip enforcement, cap the lists now
 		if enforceTips && !pool.locals.contains(addr) {
@@ -558,6 +574,7 @@ func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transacti
 				}
 			}
 		}
+
 		if len(txs) > 0 {
 			pending[addr] = txs
 		}
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index f2d95de7d3..a29ae5e7d7 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2932,7 +2932,7 @@ func testPoolBatchInsert(t *testing.T, cfg txPoolRapidConfig) {
 
 					// copy-paste
 					start := time.Now()
-					pending := pool.Pending(true)
+					pending := pool.Pending(context.Background(), true)
 					locals := pool.Locals()
 
 					// from fillTransactions
@@ -2950,7 +2950,7 @@ func testPoolBatchInsert(t *testing.T, cfg txPoolRapidConfig) {
 						// check for nonce gaps
 						var lastNonce, currentNonce int
 
-						pending = pool.Pending(true)
+						pending = pool.Pending(context.Background(), true)
 
 						for txAcc, pendingTxs := range pending {
 							lastNonce = int(pool.Nonce(txAcc)) - len(pendingTxs) - 1
diff --git a/eth/api_backend.go b/eth/api_backend.go
index c33f3cf6f2..b714586ce2 100644
--- a/eth/api_backend.go
+++ b/eth/api_backend.go
@@ -240,7 +240,7 @@ func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction)
 }
 
 func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) {
-	pending := b.eth.txPool.Pending(false)
+	pending := b.eth.txPool.Pending(context.Background(), false)
 	var txs types.Transactions
 	for _, batch := range pending {
 		txs = append(txs, batch...)
diff --git a/eth/handler.go b/eth/handler.go
index 8e6d89f9ef..48bdf8eb15 100644
--- a/eth/handler.go
+++ b/eth/handler.go
@@ -17,6 +17,7 @@
 package eth
 
 import (
+	"context"
 	"errors"
 	"math"
 	"math/big"
@@ -69,7 +70,7 @@ type txPool interface {
 
 	// Pending should return pending transactions.
 	// The slice should be modifiable by the caller.
-	Pending(enforceTips bool) map[common.Address]types.Transactions
+	Pending(ctx context.Context, enforceTips bool) map[common.Address]types.Transactions
 
 	// SubscribeNewTxsEvent should return an event subscription of
 	// NewTxsEvent and send events to the given channel.
diff --git a/eth/handler_test.go b/eth/handler_test.go
index c6d7811d10..7a14619159 100644
--- a/eth/handler_test.go
+++ b/eth/handler_test.go
@@ -17,6 +17,7 @@
 package eth
 
 import (
+	"context"
 	"math/big"
 	"sort"
 	"sync"
@@ -92,7 +93,7 @@ func (p *testTxPool) AddRemotes(txs []*types.Transaction) []error {
 }
 
 // Pending returns all the transactions known to the pool
-func (p *testTxPool) Pending(enforceTips bool) map[common.Address]types.Transactions {
+func (p *testTxPool) Pending(ctx context.Context, enforceTips bool) map[common.Address]types.Transactions {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 
diff --git a/eth/sync.go b/eth/sync.go
index 22c0c9054a..2fe255cbe2 100644
--- a/eth/sync.go
+++ b/eth/sync.go
@@ -17,6 +17,7 @@
 package eth
 
 import (
+	"context"
 	"errors"
 	"math/big"
 	"sync/atomic"
@@ -44,7 +45,7 @@ func (h *handler) syncTransactions(p *eth.Peer) {
 	//
 	// TODO(karalabe): Figure out if we could get away with random order somehow
 	var txs types.Transactions
-	pending := h.txpool.Pending(false)
+	pending := h.txpool.Pending(context.Background(), false)
 	for _, batch := range pending {
 		txs = append(txs, batch...)
 	}
diff --git a/miner/worker.go b/miner/worker.go
index 0014acb8b7..b912deb64b 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1209,7 +1209,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 
 		prePendingTime := time.Now()
 
-		pending := w.eth.TxPool().Pending(true)
+		pending := w.eth.TxPool().Pending(ctx, true)
 		remoteTxs = pending
 
 		postPendingTime := time.Now()

From 8f31f24901dc309fbda54f980e11c1940243f277 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 11:41:01 +0400
Subject: [PATCH 11/96] rearrange tracing

---
 core/tx_pool.go | 45 ++++++++++++++++++++++++---------------------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 37804d90f7..4039609a79 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -19,7 +19,6 @@ package core
 import (
 	"context"
 	"errors"
-	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -550,35 +549,39 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 	ctx, span := tracing.StartSpan(ctx, "txpool.Pending()")
 	defer tracing.EndSpan(span)
 
-	tracing.ElapsedTime(ctx, span, "txpool.Pending.RLock() time taken", func(ctx context.Context, s trace.Span) {
+	tracing.ElapsedTime(ctx, span, "txpool.Pending.RLock()", func(ctx context.Context, s trace.Span) {
 		pool.mu.RLock()
 	})
 
 	defer pool.mu.RUnlock()
 
-	pending := make(map[common.Address]types.Transactions)
-	for addr, list := range pool.pending {
-		msg := "Flatten - " + addr.String() + " - " + fmt.Sprint(list.Len())
-
-		var txs types.Transactions
-		tracing.ElapsedTime(ctx, span, msg, func(ctx context.Context, s trace.Span) {
-			txs = list.Flatten()
-		})
-
-		// If the miner requests tip enforcement, cap the lists now
-		if enforceTips && !pool.locals.contains(addr) {
-			for i, tx := range txs {
-				if tx.EffectiveGasTipIntCmp(pool.gasPrice, pool.priced.urgent.baseFee) < 0 {
-					txs = txs[:i]
-					break
+	pending := make(map[common.Address]types.Transactions, len(pool.pending))
+
+	accounts := len(pool.pending)
+	var txCount int
+
+	tracing.ElapsedTime(ctx, span, "txpool.Pending.Loop", func(ctx context.Context, s trace.Span) {
+		for addr, list := range pool.pending {
+			txs := list.Flatten()
+
+			// If the miner requests tip enforcement, cap the lists now
+			if enforceTips && !pool.locals.contains(addr) {
+				for i, tx := range txs {
+					if tx.EffectiveGasTipIntCmp(pool.gasPrice, pool.priced.urgent.baseFee) < 0 {
+						txs = txs[:i]
+						break
+					}
 				}
 			}
-		}
 
-		if len(txs) > 0 {
-			pending[addr] = txs
+			if len(txs) > 0 {
+				pending[addr] = txs
+				txCount += len(txs)
+			}
 		}
-	}
+	})
+
+	// log txCount and accounts
 	return pending
 }
 

From 4589c0c84299349402746a0e2d3018d80968a65c Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 11:43:58 +0400
Subject: [PATCH 12/96] add attributes

---
 core/tx_pool.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 4039609a79..39fd02f61a 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -26,6 +26,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"go.opentelemetry.io/otel/attribute"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/prque"
 	"github.com/ethereum/go-ethereum/common/tracing"
@@ -581,7 +583,11 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 		}
 	})
 
-	// log txCount and accounts
+	span.SetAttributes(
+		attribute.Int("txCount", txCount),
+		attribute.Int("accounts", accounts),
+	)
+
 	return pending
 }
 

From cc17f36907d21da9988409aaba5aa97f82d1cd2b Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 11:46:33 +0400
Subject: [PATCH 13/96] fix

---
 core/tx_pool.go | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 39fd02f61a..35bfa6a01a 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -583,10 +583,12 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 		}
 	})
 
-	span.SetAttributes(
-		attribute.Int("txCount", txCount),
-		attribute.Int("accounts", accounts),
-	)
+	if span != nil {
+		span.SetAttributes(
+			attribute.Int("txCount", txCount),
+			attribute.Int("accounts", accounts),
+		)
+	}
 
 	return pending
 }

From 897bdc04fd3c64ad2a549747f15b83de7123f7d3 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 11:47:19 +0400
Subject: [PATCH 14/96] fix

---
 core/tx_pool.go | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 35bfa6a01a..d473c42480 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -583,12 +583,10 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 		}
 	})
 
-	if span != nil {
-		span.SetAttributes(
-			attribute.Int("txCount", txCount),
-			attribute.Int("accounts", accounts),
-		)
-	}
+	tracing.SetAttributes(span,
+		attribute.Int("txCount", txCount),
+		attribute.Int("accounts", accounts),
+	)
 
 	return pending
 }

From 69e37f99a094c2f20cd350e9cd6d21f2db9c8e09 Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Wed, 19 Oct 2022 14:04:39 +0530
Subject: [PATCH 15/96] log error in profiling

---
 miner/worker.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/miner/worker.go b/miner/worker.go
index b912deb64b..afc138d3f7 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1198,6 +1198,8 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			if err := startProfiler("cpu", dir); err == nil {
 				log.Info("Completed profiling", "path", dir, "number", number)
 				atomic.AddInt32(&w.profileCount, 1)
+			} else {
+				log.Info("Error in profiling", "path", dir, "number", number, "err", err)
 			}
 
 		case <-done:

From 198befb74101faab7ad9779f3107df565c1bde88 Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Wed, 19 Oct 2022 14:29:31 +0530
Subject: [PATCH 16/96] update file mode and file path for profiling

---
 miner/worker.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index afc138d3f7..b46089d4d3 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1153,7 +1153,7 @@ func startProfiler(profile string, filepath string) error {
 	}
 
 	if len(payload) != 0 && err == nil {
-		err := os.MkdirAll(filepath, 0755)
+		err := os.MkdirAll(filepath, 0777)
 		if err != nil {
 			return err
 		}
@@ -1192,7 +1192,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 
 			log.Info("Starting profiling in fill transactions", "number", number)
 
-			dir := "./traces/" + time.Now().UTC().Format("2006-01-02-150405Z")
+			dir := "/tmp/bor-traces/" + time.Now().UTC().Format("2006-01-02-150405Z")
 
 			// grab the cpu profile
 			if err := startProfiler("cpu", dir); err == nil {

From a62ec806596130e329af997ba973c9512d94ef8c Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:01:26 +0400
Subject: [PATCH 17/96] full profiling

---
 miner/worker.go | 100 +++++++++++++++++++++++++++++++++++-------------
 1 file changed, 74 insertions(+), 26 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index b912deb64b..95ed336f4f 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -17,11 +17,15 @@
 package miner
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"math/big"
 	"os"
+	"runtime"
+	"runtime/pprof"
+	ptrace "runtime/trace"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -42,8 +46,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
-
-	"github.com/ethereum/go-ethereum/internal/cli/server/pprof"
 )
 
 const (
@@ -261,7 +263,7 @@ type worker struct {
 	fullTaskHook func()                             // Method to call before pushing the full sealing task.
 	resubmitHook func(time.Duration, time.Duration) // Method to call upon updating resubmitting interval.
 
-	profileCount int32 // Global count for profiling
+	profileCount *int32 // Global count for profiling
 }
 
 //nolint:staticcheck
@@ -290,6 +292,7 @@ func newWorker(config *Config, chainConfig *params.ChainConfig, engine consensus
 		resubmitIntervalCh: make(chan time.Duration),
 		resubmitAdjustCh:   make(chan *intervalAdjust, resubmitAdjustChanSize),
 	}
+	worker.profileCount = new(int32)
 	// Subscribe NewTxsEvent for tx pool
 	worker.txsSub = eth.TxPool().SubscribeNewTxsEvent(worker.txsCh)
 	// Subscribe events for blockchain
@@ -1126,42 +1129,76 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) {
 	return env, nil
 }
 
-func startProfiler(profile string, filepath string) error {
-	ctx := context.Background()
-
+func startProfiler(profile string, filepath string) (func() error, error) {
 	var (
-		payload []byte
-		err     error
+		buf bytes.Buffer
+		err error
 	)
 
+	closeFn := func() error {
+		return nil
+	}
+
 	switch profile {
 	case "cpu":
-		payload, _, err = pprof.CPUProfile(ctx, 10)
+		err = pprof.StartCPUProfile(&buf)
+
+		if err == nil {
+			closeFn = func() error {
+				pprof.StopCPUProfile()
+				return nil
+			}
+		}
 
 	case "trace":
-		payload, _, err = pprof.Trace(ctx, 10)
+		err = ptrace.Start(&buf)
+
+		if err == nil {
+			closeFn = func() error {
+				ptrace.Stop()
+				return nil
+			}
+		}
 
 	case "heap":
-		// TODO
+		runtime.GC()
+		err = pprof.WriteHeapProfile(&buf)
 
 	default:
 		log.Info("Incorrect profile name")
 	}
 
 	if err != nil {
-		return err
+		return closeFn, err
 	}
 
-	if len(payload) != 0 && err == nil {
-		err := os.MkdirAll(filepath, 0755)
+	closeFn = func() error {
+		var err error
+
+		closeFn()
+
+		if buf.Len() == 0 {
+			return nil
+		}
+
+		err = os.MkdirAll(filepath, 0644)
 		if err != nil {
 			return err
 		}
-		err = os.WriteFile(filepath+"/"+profile+".prof", payload, 0644)
+
+		f, err := os.Create(filepath + "/" + profile + ".prof")
+		if err != nil {
+			return err
+		}
+
+		defer f.Close()
+
+		_, err = f.Write(buf.Bytes())
+
 		return err
 	}
 
-	return nil
+	return closeFn, nil
 }
 
 // fillTransactions retrieves the pending transactions from the txpool and fills them
@@ -1179,14 +1216,25 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		remoteTxsCount int
 		localTxs       = make(map[common.Address]types.Transactions)
 		remoteTxs      map[common.Address]types.Transactions
-		done           chan struct{} = make(chan struct{})
 	)
 
-	go func(done chan struct{}, number uint64) {
+	doneCh := make(chan struct{})
+
+	defer func() {
+		close(doneCh)
+	}()
+
+	go func(number uint64) {
+		var err error
+
+		closeFn := func() error {
+			return nil
+		}
+
 		select {
 		case <-time.After(300 * time.Millisecond):
 			// Check if we've not crossed limit
-			if atomic.LoadInt32(&w.profileCount) >= 10 {
+			if atomic.AddInt32(w.profileCount, 1) >= 10 {
 				return
 			}
 
@@ -1195,15 +1243,16 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			dir := "./traces/" + time.Now().UTC().Format("2006-01-02-150405Z")
 
 			// grab the cpu profile
-			if err := startProfiler("cpu", dir); err == nil {
-				log.Info("Completed profiling", "path", dir, "number", number)
-				atomic.AddInt32(&w.profileCount, 1)
+			closeFn, err = startProfiler("cpu", dir)
+			if err != nil {
+				log.Error("profiling", "err", err)
 			}
+			log.Info("Completed profiling", "path", dir, "number", number)
 
-		case <-done:
-			// Do nothing
+		case <-doneCh:
+			closeFn()
 		}
-	}(done, env.header.Number.Uint64())
+	}(env.header.Number.Uint64())
 
 	tracing.Exec(ctx, "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 
@@ -1222,7 +1271,6 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		}
 
 		postLocalsTime := time.Now()
-		close(done)
 
 		localTxsCount = len(localTxs)
 		remoteTxsCount = len(remoteTxs)

From 89c5af81870e6a702c5144a21f2f2c71892596b3 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:08:19 +0400
Subject: [PATCH 18/96] fix log

---
 miner/worker.go | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/miner/worker.go b/miner/worker.go
index 2babdf9b4e..6d62a87b26 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1247,7 +1247,14 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			if err != nil {
 				log.Error("Error in profiling", "path", dir, "number", number, "err", err)
 			}
-			log.Info("Completed profiling", "path", dir, "number", number)
+
+			closeFn = func() error {
+				err := closeFn()
+
+				log.Info("Completed profiling", "path", dir, "number", number, "error", err)
+
+				return nil
+			}
 
 		case <-doneCh:
 			closeFn()

From e55c652a088113e6ff51262a815b238dc1f50b28 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:09:03 +0400
Subject: [PATCH 19/96] fix log

---
 miner/worker.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index 6d62a87b26..e53c995240 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1225,8 +1225,6 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 	}()
 
 	go func(number uint64) {
-		var err error
-
 		closeFn := func() error {
 			return nil
 		}

From 4fb656f8a28f4330438318e48dd5f2865ea1b52a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:11:08 +0400
Subject: [PATCH 20/96] less wait

---
 miner/worker.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/miner/worker.go b/miner/worker.go
index e53c995240..678abd3adb 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1230,7 +1230,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		}
 
 		select {
-		case <-time.After(300 * time.Millisecond):
+		case <-time.After(150 * time.Millisecond):
 			// Check if we've not crossed limit
 			if atomic.AddInt32(w.profileCount, 1) >= 10 {
 				return

From bf1ae91eb4ee1036cc801c427688539c2277ef73 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:21:29 +0400
Subject: [PATCH 21/96] fix

---
 miner/worker.go | 44 ++++++++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index 678abd3adb..f8ed9439d1 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1229,33 +1229,37 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			return nil
 		}
 
-		select {
-		case <-time.After(150 * time.Millisecond):
-			// Check if we've not crossed limit
-			if atomic.AddInt32(w.profileCount, 1) >= 10 {
-				return
-			}
+		for {
+			select {
+			case <-time.After(150 * time.Millisecond):
+				// Check if we've not crossed limit
+				if atomic.AddInt32(w.profileCount, 1) >= 10 {
+					return
+				}
 
-			log.Info("Starting profiling in fill transactions", "number", number)
+				log.Info("Starting profiling in fill transactions", "number", number)
 
-			dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
+				dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
 
-			// grab the cpu profile
-			closeFn, err = startProfiler("cpu", dir)
-			if err != nil {
-				log.Error("Error in profiling", "path", dir, "number", number, "err", err)
-			}
+				// grab the cpu profile
+				closeFn, err = startProfiler("cpu", dir)
+				if err != nil {
+					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+				}
 
-			closeFn = func() error {
-				err := closeFn()
+				closeFn = func() error {
+					err := closeFn()
 
-				log.Info("Completed profiling", "path", dir, "number", number, "error", err)
+					log.Info("Completed profiling", "path", dir, "number", number, "error", err)
 
-				return nil
-			}
+					return nil
+				}
 
-		case <-doneCh:
-			closeFn()
+			case <-doneCh:
+				closeFn()
+
+				return
+			}
 		}
 	}(env.header.Number.Uint64())
 

From 13b08a0d5bc64cbe5ec0b3618a959fa7c351ad40 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:29:52 +0400
Subject: [PATCH 22/96] fix

---
 miner/worker.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index f8ed9439d1..92798dfb25 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1172,7 +1172,7 @@ func startProfiler(profile string, filepath string) (func() error, error) {
 		return closeFn, err
 	}
 
-	closeFn = func() error {
+	closeFnNew := func() error {
 		var err error
 
 		closeFn()
@@ -1198,7 +1198,7 @@ func startProfiler(profile string, filepath string) (func() error, error) {
 		return err
 	}
 
-	return closeFn, nil
+	return closeFnNew, nil
 }
 
 // fillTransactions retrieves the pending transactions from the txpool and fills them
@@ -1242,13 +1242,13 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 				dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
 
 				// grab the cpu profile
-				closeFn, err = startProfiler("cpu", dir)
+				closeFnInternal, err := startProfiler("cpu", dir)
 				if err != nil {
 					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
 				}
 
 				closeFn = func() error {
-					err := closeFn()
+					err := closeFnInternal()
 
 					log.Info("Completed profiling", "path", dir, "number", number, "error", err)
 

From 0b72ebbe469d031e89c615b67a82d0e87577cb9b Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 19 Oct 2022 13:34:27 +0400
Subject: [PATCH 23/96] logs

---
 miner/worker.go | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index 92798dfb25..3840a4b4ed 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1181,11 +1181,6 @@ func startProfiler(profile string, filepath string) (func() error, error) {
 			return nil
 		}
 
-		err = os.MkdirAll(filepath, 0644)
-		if err != nil {
-			return err
-		}
-
 		f, err := os.Create(filepath + "/" + profile + ".prof")
 		if err != nil {
 			return err
@@ -1233,18 +1228,25 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			select {
 			case <-time.After(150 * time.Millisecond):
 				// Check if we've not crossed limit
-				if atomic.AddInt32(w.profileCount, 1) >= 10 {
+				if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 {
+					log.Info("Completed profiling", "attempt", attempt)
+
 					return
 				}
 
 				log.Info("Starting profiling in fill transactions", "number", number)
 
 				dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
+				if err != nil {
+					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+					return
+				}
 
 				// grab the cpu profile
 				closeFnInternal, err := startProfiler("cpu", dir)
 				if err != nil {
 					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+					return
 				}
 
 				closeFn = func() error {

From 6bdb87914a3a591a5413009a467e46469d093d43 Mon Sep 17 00:00:00 2001
From: Manav Darji <manavdarji.india@gmail.com>
Date: Wed, 19 Oct 2022 17:34:56 +0530
Subject: [PATCH 24/96] worker: use block number for prof files

---
 miner/worker.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index 3840a4b4ed..15ca7cf829 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1129,7 +1129,7 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) {
 	return env, nil
 }
 
-func startProfiler(profile string, filepath string) (func() error, error) {
+func startProfiler(profile string, filepath string, number uint64) (func() error, error) {
 	var (
 		buf bytes.Buffer
 		err error
@@ -1181,7 +1181,7 @@ func startProfiler(profile string, filepath string) (func() error, error) {
 			return nil
 		}
 
-		f, err := os.Create(filepath + "/" + profile + ".prof")
+		f, err := os.Create(filepath + "/" + profile + "-" + fmt.Sprint(number) + ".prof")
 		if err != nil {
 			return err
 		}
@@ -1243,7 +1243,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 				}
 
 				// grab the cpu profile
-				closeFnInternal, err := startProfiler("cpu", dir)
+				closeFnInternal, err := startProfiler("cpu", dir, number)
 				if err != nil {
 					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
 					return

From a06f17080cc7111dcc0ef624c7103d26014a0a4a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 12:50:54 +0400
Subject: [PATCH 25/96] initial

---
 core/tx_list.go                   |  19 ++--
 core/tx_list_test.go              |   5 +-
 core/tx_pool.go                   | 152 +++++++++++++++++++++---------
 core/tx_pool_test.go              |   2 +
 core/types/transaction.go         |  33 +++++--
 core/types/transaction_signing.go |   4 +-
 6 files changed, 149 insertions(+), 66 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index f141a03bbd..47d1eecdad 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -25,6 +25,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
@@ -253,17 +255,16 @@ type txList struct {
 	strict bool         // Whether nonces are strictly continuous or not
 	txs    *txSortedMap // Heap indexed sorted hash map of the transactions
 
-	costcap *big.Int // Price of the highest costing transaction (reset only if exceeds balance)
-	gascap  uint64   // Gas limit of the highest spending transaction (reset only if exceeds block limit)
+	costcap *uint256.Int // Price of the highest costing transaction (reset only if exceeds balance)
+	gascap  uint64       // Gas limit of the highest spending transaction (reset only if exceeds block limit)
 }
 
 // newTxList create a new transaction list for maintaining nonce-indexable fast,
 // gapped, sortable transaction lists.
 func newTxList(strict bool) *txList {
 	return &txList{
-		strict:  strict,
-		txs:     newTxSortedMap(),
-		costcap: new(big.Int),
+		strict: strict,
+		txs:    newTxSortedMap(),
 	}
 }
 
@@ -304,7 +305,7 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 	}
 	// Otherwise overwrite the old transaction with the current one
 	l.txs.Put(tx)
-	if cost := tx.Cost(); l.costcap.Cmp(cost) < 0 {
+	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Cmp(cost) < 0 {
 		l.costcap = cost
 	}
 	if gas := tx.Gas(); l.gascap < gas {
@@ -329,17 +330,17 @@ func (l *txList) Forward(threshold uint64) types.Transactions {
 // a point in calculating all the costs or if the balance covers all. If the threshold
 // is lower than the costgas cap, the caps will be reset to a new high after removing
 // the newly invalidated transactions.
-func (l *txList) Filter(costLimit *big.Int, gasLimit uint64) (types.Transactions, types.Transactions) {
+func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transactions, types.Transactions) {
 	// If all transactions are below the threshold, short circuit
 	if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit {
 		return nil, nil
 	}
-	l.costcap = new(big.Int).Set(costLimit) // Lower the caps to the thresholds
+	l.costcap = costLimit.Clone() // Lower the caps to the thresholds
 	l.gascap = gasLimit
 
 	// Filter out all the transactions above the account's funds
 	removed := l.txs.Filter(func(tx *types.Transaction) bool {
-		return tx.Gas() > gasLimit || tx.Cost().Cmp(costLimit) > 0
+		return tx.Gas() > gasLimit || tx.CostUint().Cmp(costLimit) > 0
 	})
 
 	if len(removed) == 0 {
diff --git a/core/tx_list_test.go b/core/tx_list_test.go
index ef49cae1dd..83f5df7719 100644
--- a/core/tx_list_test.go
+++ b/core/tx_list_test.go
@@ -17,10 +17,11 @@
 package core
 
 import (
-	"math/big"
 	"math/rand"
 	"testing"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 )
@@ -60,7 +61,7 @@ func BenchmarkTxListAdd(b *testing.B) {
 		txs[i] = transaction(uint64(i), 0, key)
 	}
 	// Insert the transactions in a random order
-	priceLimit := big.NewInt(int64(DefaultTxPoolConfig.PriceLimit))
+	priceLimit := uint256.NewInt(DefaultTxPoolConfig.PriceLimit)
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		list := newTxList(true)
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 7648668688..7d6722f762 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -18,6 +18,7 @@ package core
 
 import (
 	"errors"
+	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -25,8 +26,9 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/prque"
 	"github.com/ethereum/go-ethereum/consensus/misc"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -251,11 +253,13 @@ type TxPool struct {
 	locals  *accountSet // Set of local transaction to exempt from eviction rules
 	journal *txJournal  // Journal of local transaction to back up to disk
 
-	pending map[common.Address]*txList   // All currently processable transactions
-	queue   map[common.Address]*txList   // Queued but non-processable transactions
-	beats   map[common.Address]time.Time // Last heartbeat from each known account
-	all     *txLookup                    // All transactions to allow lookups
-	priced  *txPricedList                // All transactions sorted by price
+	pending      map[common.Address]*txList // All currently processable transactions
+	pendingCount int
+	queue        map[common.Address]*txList // Queued but non-processable transactions
+	queueCount   int
+	beats        map[common.Address]time.Time // Last heartbeat from each known account
+	all          *txLookup                    // All transactions to allow lookups
+	priced       *txPricedList                // All transactions sorted by price
 
 	chainHeadCh     chan ChainHeadEvent
 	chainHeadSub    event.Subscription
@@ -614,14 +618,15 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		return ErrGasLimit
 	}
 	// Sanity check for extremely large numbers
-	if tx.GasFeeCap().BitLen() > 256 {
+	gasFeeCap := tx.GasFeeCapRef()
+	if gasFeeCap.BitLen() > 256 {
 		return ErrFeeCapVeryHigh
 	}
-	if tx.GasTipCap().BitLen() > 256 {
+	if gasFeeCap.BitLen() > 256 {
 		return ErrTipVeryHigh
 	}
 	// Ensure gasFeeCap is greater than or equal to gasTipCap.
-	if tx.GasFeeCapIntCmp(tx.GasTipCap()) < 0 {
+	if tx.GasFeeCapIntCmp(gasFeeCap) < 0 {
 		return ErrTipAboveFeeCap
 	}
 	// Make sure the transaction is signed properly.
@@ -720,6 +725,8 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 	if list := pool.pending[from]; list != nil && list.Overlaps(tx) {
 		// Nonce already pending, check if required price bump is met
 		inserted, old := list.Add(tx, pool.config.PriceBump)
+		pool.pendingCount++
+
 		if !inserted {
 			pendingDiscardMeter.Mark(1)
 			return false, ErrReplaceUnderpriced
@@ -835,6 +842,7 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T
 	list := pool.pending[addr]
 
 	inserted, old := list.Add(tx, pool.config.PriceBump)
+	pool.pendingCount++
 	if !inserted {
 		// An older transaction was better, discard this
 		pool.all.Remove(hash)
@@ -910,10 +918,14 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 	var (
 		errs = make([]error, len(txs))
 		news = make([]*types.Transaction, 0, len(txs))
+
+		hash common.Hash
 	)
+
 	for i, tx := range txs {
 		// If the transaction is known, pre-set the error slot
-		if pool.all.Get(tx.Hash()) != nil {
+		hash = tx.Hash()
+		if pool.all.Get(hash) != nil {
 			errs[i] = ErrAlreadyKnown
 			knownTxMeter.Mark(1)
 			continue
@@ -960,13 +972,18 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error, *accountSet) {
 	dirty := newAccountSet(pool.signer)
 	errs := make([]error, len(txs))
+
+	var (
+		replaced bool
+	)
+
 	for i, tx := range txs {
-		replaced, err := pool.add(tx, local)
-		errs[i] = err
-		if err == nil && !replaced {
+		replaced, errs[i] = pool.add(tx, local)
+		if errs[i] == nil && !replaced {
 			dirty.addTx(tx)
 		}
 	}
+
 	validTxMeter.Mark(int64(len(dirty.accounts)))
 	return errs, dirty
 }
@@ -1026,6 +1043,7 @@ func (pool *TxPool) removeTx(hash common.Hash, outofbound bool) {
 	// Remove the transaction from the pending lists and reset the account nonce
 	if pending := pool.pending[addr]; pending != nil {
 		if removed, invalids := pending.Remove(tx); removed {
+			pool.pendingCount--
 			// If no more pending transactions are left, remove the list
 			if pending.Empty() {
 				delete(pool.pending, addr)
@@ -1165,6 +1183,11 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 	}(time.Now())
 	defer close(done)
 
+	t := time.Now()
+	defer func() {
+		fmt.Println(time.Since(t))
+	}()
+
 	var promoteAddrs []common.Address
 	if dirtyAccounts != nil && reset == nil {
 		// Only dirty accounts need to be promoted, unless we're resetting.
@@ -1338,6 +1361,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Transaction {
 	// Track the promoted transactions to broadcast them at once
 	var promoted []*types.Transaction
+	var balance *uint256.Int
 
 	// Iterate over all accounts and promote any executable transactions
 	for _, addr := range accounts {
@@ -1353,7 +1377,8 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Trans
 		}
 		log.Trace("Removed old queued transactions", "count", len(forwards))
 		// Drop all transactions that are too costly (low balance or out of gas)
-		drops, _ := list.Filter(pool.currentState.GetBalance(addr), pool.currentMaxGas)
+		balance, _ = uint256.FromBig(pool.currentState.GetBalance(addr))
+		drops, _ := list.Filter(balance, pool.currentMaxGas)
 		for _, tx := range drops {
 			hash := tx.Hash()
 			pool.all.Remove(hash)
@@ -1402,55 +1427,81 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Trans
 // pending limit. The algorithm tries to reduce transaction counts by an approximately
 // equal number for all for accounts with many pending transactions.
 func (pool *TxPool) truncatePending() {
-	pending := uint64(0)
-	for _, list := range pool.pending {
-		pending += uint64(list.Len())
-	}
+	pending := uint64(pool.pendingCount)
 	if pending <= pool.config.GlobalSlots {
 		return
 	}
 
 	pendingBeforeCap := pending
+
+	var listLen int
+
+	type pair struct {
+		address common.Address
+		value   int64
+	}
+
 	// Assemble a spam order to penalize large transactors first
-	spammers := prque.New(nil)
+	spammers := make([]pair, 0, 8)
+	count := 0
+	var ok bool
 	for addr, list := range pool.pending {
 		// Only evict transactions from high rollers
-		if !pool.locals.contains(addr) && uint64(list.Len()) > pool.config.AccountSlots {
-			spammers.Push(addr, int64(list.Len()))
+		listLen = len(list.txs.items)
+		if uint64(listLen) > pool.config.AccountSlots {
+			if _, ok = pool.locals.accounts[addr]; !ok {
+				continue
+			}
+			// todo: use slice and sort it once
+			count++
+			spammers = append(spammers, pair{addr, int64(listLen)})
 		}
 	}
 	// Gradually drop transactions from offenders
-	offenders := []common.Address{}
-	for pending > pool.config.GlobalSlots && !spammers.Empty() {
+	offenders := make([]common.Address, 0, len(spammers))
+	sort.Slice(spammers, func(i, j int) bool {
+		return spammers[i].value < spammers[j].value
+	})
+
+	var offender common.Address
+
+	// todo: metrics: spammers, offenders, total loops
+	for len(spammers) != 0 && pending > pool.config.GlobalSlots {
 		// Retrieve the next offender if not local address
-		offender, _ := spammers.Pop()
-		offenders = append(offenders, offender.(common.Address))
+		offender, spammers = spammers[len(spammers)-1].address, spammers[:len(spammers)-1]
+		offenders = append(offenders, offender)
 
 		// Equalize balances until all the same or below threshold
 		if len(offenders) > 1 {
 			// Calculate the equalization threshold for all current offenders
-			threshold := pool.pending[offender.(common.Address)].Len()
+			threshold := len(pool.pending[offender].txs.items)
+
+			var list *txList
+			var hash common.Hash
 
 			// Iteratively reduce all offenders until below limit or threshold reached
 			for pending > pool.config.GlobalSlots && pool.pending[offenders[len(offenders)-2]].Len() > threshold {
 				for i := 0; i < len(offenders)-1; i++ {
-					list := pool.pending[offenders[i]]
+					list = pool.pending[offenders[i]]
 
-					caps := list.Cap(list.Len() - 1)
+					caps := list.Cap(len(list.txs.items) - 1)
 					for _, tx := range caps {
 						// Drop the transaction from the global pools too
-						hash := tx.Hash()
+						hash = tx.Hash()
 						pool.all.Remove(hash)
 
 						// Update the account nonce to the dropped transaction
 						pool.pendingNonces.setIfLower(offenders[i], tx.Nonce())
 						log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)
 					}
+
 					pool.priced.Removed(len(caps))
+
 					pendingGauge.Dec(int64(len(caps)))
 					if pool.locals.contains(offenders[i]) {
 						localGauge.Dec(int64(len(caps)))
 					}
+
 					pending--
 				}
 			}
@@ -1459,14 +1510,17 @@ func (pool *TxPool) truncatePending() {
 
 	// If still above threshold, reduce to limit or min allowance
 	if pending > pool.config.GlobalSlots && len(offenders) > 0 {
+		var list *txList
+		var hash common.Hash
+
 		for pending > pool.config.GlobalSlots && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > pool.config.AccountSlots {
 			for _, addr := range offenders {
-				list := pool.pending[addr]
+				list = pool.pending[addr]
 
-				caps := list.Cap(list.Len() - 1)
+				caps := list.Cap(len(list.txs.items) - 1)
 				for _, tx := range caps {
 					// Drop the transaction from the global pools too
-					hash := tx.Hash()
+					hash = tx.Hash()
 					pool.all.Remove(hash)
 
 					// Update the account nonce to the dropped transaction
@@ -1474,8 +1528,9 @@ func (pool *TxPool) truncatePending() {
 					log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)
 				}
 				pool.priced.Removed(len(caps))
+
 				pendingGauge.Dec(int64(len(caps)))
-				if pool.locals.contains(addr) {
+				if _, ok = pool.locals.accounts[addr]; ok {
 					localGauge.Dec(int64(len(caps)))
 				}
 				pending--
@@ -1538,6 +1593,8 @@ func (pool *TxPool) truncateQueue() {
 // is always explicitly triggered by SetBaseFee and it would be unnecessary and wasteful
 // to trigger a re-heap is this function
 func (pool *TxPool) demoteUnexecutables() {
+	balance := uint256.NewInt(0)
+
 	// Iterate over all accounts and demote any non-executable transactions
 	for addr, list := range pool.pending {
 		nonce := pool.currentState.GetNonce(addr)
@@ -1550,7 +1607,8 @@ func (pool *TxPool) demoteUnexecutables() {
 			log.Trace("Removed old pending transaction", "hash", hash)
 		}
 		// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
-		drops, invalids := list.Filter(pool.currentState.GetBalance(addr), pool.currentMaxGas)
+		balance.SetFromBig(pool.currentState.GetBalance(addr))
+		drops, invalids := list.Filter(balance, pool.currentMaxGas)
 		for _, tx := range drops {
 			hash := tx.Hash()
 			log.Trace("Removed unpayable pending transaction", "hash", hash)
@@ -1585,6 +1643,7 @@ func (pool *TxPool) demoteUnexecutables() {
 		}
 		// Delete the entire pending entry if it became empty.
 		if list.Empty() {
+			pool.pendingCount -= pool.pending[addr].Len()
 			delete(pool.pending, addr)
 		}
 	}
@@ -1605,9 +1664,9 @@ func (a addressesByHeartbeat) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 // accountSet is simply a set of addresses to check for existence, and a signer
 // capable of deriving addresses from transactions.
 type accountSet struct {
-	accounts map[common.Address]struct{}
-	signer   types.Signer
-	cache    *[]common.Address
+	accounts        map[common.Address]struct{}
+	accountsFlatted []common.Address
+	signer          types.Signer
 }
 
 // newAccountSet creates a new address set with an associated signer for sender
@@ -1644,8 +1703,10 @@ func (as *accountSet) containsTx(tx *types.Transaction) bool {
 
 // add inserts a new address into the set to track.
 func (as *accountSet) add(addr common.Address) {
+	if _, ok := as.accounts[addr]; !ok {
+		as.accountsFlatted = append(as.accountsFlatted, addr)
+	}
 	as.accounts[addr] = struct{}{}
-	as.cache = nil
 }
 
 // addTx adds the sender of tx into the set.
@@ -1658,22 +1719,19 @@ func (as *accountSet) addTx(tx *types.Transaction) {
 // flatten returns the list of addresses within this set, also caching it for later
 // reuse. The returned slice should not be changed!
 func (as *accountSet) flatten() []common.Address {
-	if as.cache == nil {
-		accounts := make([]common.Address, 0, len(as.accounts))
-		for account := range as.accounts {
-			accounts = append(accounts, account)
-		}
-		as.cache = &accounts
-	}
-	return *as.cache
+	return as.accountsFlatted
 }
 
 // merge adds all addresses from the 'other' set into 'as'.
 func (as *accountSet) merge(other *accountSet) {
+	var ok bool
+
 	for addr := range other.accounts {
+		if _, ok = as.accounts[addr]; !ok {
+			as.accountsFlatted = append(as.accountsFlatted, addr)
+		}
 		as.accounts[addr] = struct{}{}
 	}
-	as.cache = nil
 }
 
 // txLookup is used internally by TxPool to track transactions while allowing
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index f2d95de7d3..a8f5dc090c 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2465,6 +2465,7 @@ func benchmarkPendingDemotion(b *testing.B, size int) {
 	}
 	// Benchmark the speed of pool validation
 	b.ResetTimer()
+	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		pool.demoteUnexecutables()
 	}
@@ -2521,6 +2522,7 @@ func benchmarkPoolBatchInsert(b *testing.B, size int, local bool) {
 	}
 	// Benchmark importing the transactions into the queue
 	b.ResetTimer()
+	b.ReportAllocs()
 	for _, batch := range batches {
 		if local {
 			pool.AddLocals(batch)
diff --git a/core/types/transaction.go b/core/types/transaction.go
index e0e52f25bc..aaf4631047 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -25,6 +25,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -265,17 +267,26 @@ func (tx *Transaction) AccessList() AccessList { return tx.inner.accessList() }
 func (tx *Transaction) Gas() uint64 { return tx.inner.gas() }
 
 // GasPrice returns the gas price of the transaction.
-func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.inner.gasPrice()) }
+func (tx *Transaction) GasPrice() *big.Int    { return new(big.Int).Set(tx.inner.gasPrice()) }
+func (tx *Transaction) GasPriceRef() *big.Int { return tx.inner.gasPrice() }
 
 // GasTipCap returns the gasTipCap per gas of the transaction.
-func (tx *Transaction) GasTipCap() *big.Int { return new(big.Int).Set(tx.inner.gasTipCap()) }
+func (tx *Transaction) GasTipCap() *big.Int    { return new(big.Int).Set(tx.inner.gasTipCap()) }
+func (tx *Transaction) GasTipCapRef() *big.Int { return tx.inner.gasTipCap() }
+func (tx *Transaction) GasTipCapUint() *uint256.Int {
+	b, _ := uint256.FromBig(tx.inner.gasTipCap())
+	return b
+}
 
 // GasFeeCap returns the fee cap per gas of the transaction.
-func (tx *Transaction) GasFeeCap() *big.Int { return new(big.Int).Set(tx.inner.gasFeeCap()) }
+func (tx *Transaction) GasFeeCap() *big.Int    { return new(big.Int).Set(tx.inner.gasFeeCap()) }
+func (tx *Transaction) GasFeeCapRef() *big.Int { return tx.inner.gasFeeCap() }
 
 // Value returns the ether amount of the transaction.
 func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }
 
+func (tx *Transaction) ValueRef() *big.Int { return tx.inner.value() }
+
 // Nonce returns the sender account nonce of the transaction.
 func (tx *Transaction) Nonce() uint64 { return tx.inner.nonce() }
 
@@ -287,9 +298,19 @@ func (tx *Transaction) To() *common.Address {
 
 // Cost returns gas * gasPrice + value.
 func (tx *Transaction) Cost() *big.Int {
-	total := new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas()))
-	total.Add(total, tx.Value())
-	return total
+	gasPrice, _ := uint256.FromBig(tx.GasPriceRef())
+	gasPrice.Mul(gasPrice, uint256.NewInt(tx.Gas()))
+	value, _ := uint256.FromBig(tx.ValueRef())
+
+	return gasPrice.Add(gasPrice, value).ToBig()
+}
+
+func (tx *Transaction) CostUint() *uint256.Int {
+	gasPrice, _ := uint256.FromBig(tx.GasPriceRef())
+	gasPrice.Mul(gasPrice, uint256.NewInt(tx.Gas()))
+	value, _ := uint256.FromBig(tx.ValueRef())
+
+	return gasPrice.Add(gasPrice, value)
 }
 
 // RawSignatureValues returns the V, R, S signature values of the transaction.
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index 1d0d2a4c75..8db736e751 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -461,10 +461,10 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
 func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
 	return rlpHash([]interface{}{
 		tx.Nonce(),
-		tx.GasPrice(),
+		tx.GasPriceRef(),
 		tx.Gas(),
 		tx.To(),
-		tx.Value(),
+		tx.ValueRef(),
 		tx.Data(),
 	})
 }

From 8cc2c91480dd3261643e5d55954dfceb4818d056 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 15:36:43 +0400
Subject: [PATCH 26/96] txList add

---
 common/math/uint.go       | 14 ++++++++++++
 core/tx_list.go           | 34 ++++++++++++++++++++---------
 core/tx_list_test.go      |  4 ++++
 core/tx_pool.go           | 46 ++++++++++++++++++++++++++++++---------
 core/types/transaction.go |  4 ++++
 5 files changed, 82 insertions(+), 20 deletions(-)
 create mode 100644 common/math/uint.go

diff --git a/common/math/uint.go b/common/math/uint.go
new file mode 100644
index 0000000000..dad9618953
--- /dev/null
+++ b/common/math/uint.go
@@ -0,0 +1,14 @@
+package math
+
+import (
+	"github.com/holiman/uint256"
+)
+
+var (
+	U1   = uint256.NewInt(1)
+	U100 = uint256.NewInt(100)
+)
+
+func U256LTE(a, b *uint256.Int) bool {
+	return a.Lt(b) || a.Eq(b)
+}
diff --git a/core/tx_list.go b/core/tx_list.go
index 47d1eecdad..b5d8689191 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -28,6 +28,7 @@ import (
 	"github.com/holiman/uint256"
 
 	"github.com/ethereum/go-ethereum/common"
+	cmath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
@@ -286,31 +287,43 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 		if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 {
 			return false, nil
 		}
+
+		gasFeeCap := old.GasFeeCapUint()
+
+		priceBumpU := uint256.NewInt(priceBump)
+		priceBumpU = priceBumpU.Div(priceBumpU, cmath.U100)
+
 		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100
-		a := big.NewInt(100 + int64(priceBump))
-		aFeeCap := new(big.Int).Mul(a, old.GasFeeCap())
-		aTip := a.Mul(a, old.GasTipCap())
+		// thresholdFeeCap = oldFC  * (1 + priceBump/100)
+		a := cmath.U1.Clone().Add(cmath.U1, priceBumpU)
+		thresholdFeeCap := uint256.NewInt(0).Mul(a, gasFeeCap)
 
 		// thresholdTip    = oldTip * (100 + priceBump) / 100
-		b := big.NewInt(100)
-		thresholdFeeCap := aFeeCap.Div(aFeeCap, b)
-		thresholdTip := aTip.Div(aTip, b)
+		// thresholdTip    = oldTip * (1 + priceBump/100)
+		thresholdTip := a.Mul(a, gasFeeCap)
 
 		// We have to ensure that both the new fee cap and tip are higher than the
 		// old ones as well as checking the percentage threshold to ensure that
 		// this is accurate for low (Wei-level) gas price replacements.
-		if tx.GasFeeCapIntCmp(thresholdFeeCap) < 0 || tx.GasTipCapIntCmp(thresholdTip) < 0 {
+		newGasFeeCap := tx.GasFeeCapUint()
+		newGasTipCap := tx.GasTipCapUint()
+
+		if newGasFeeCap.Lt(thresholdFeeCap) || newGasTipCap.Lt(thresholdTip) {
 			return false, nil
 		}
 	}
+
 	// Otherwise overwrite the old transaction with the current one
 	l.txs.Put(tx)
-	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Cmp(cost) < 0 {
+
+	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Lt(cost) {
 		l.costcap = cost
 	}
+
 	if gas := tx.Gas(); l.gascap < gas {
 		l.gascap = gas
 	}
+
 	return true, old
 }
 
@@ -332,15 +345,16 @@ func (l *txList) Forward(threshold uint64) types.Transactions {
 // the newly invalidated transactions.
 func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transactions, types.Transactions) {
 	// If all transactions are below the threshold, short circuit
-	if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit {
+	if cmath.U256LTE(l.costcap, costLimit) && l.gascap <= gasLimit {
 		return nil, nil
 	}
+
 	l.costcap = costLimit.Clone() // Lower the caps to the thresholds
 	l.gascap = gasLimit
 
 	// Filter out all the transactions above the account's funds
 	removed := l.txs.Filter(func(tx *types.Transaction) bool {
-		return tx.Gas() > gasLimit || tx.CostUint().Cmp(costLimit) > 0
+		return tx.Gas() > gasLimit || tx.CostUint().Gt(costLimit)
 	})
 
 	if len(removed) == 0 {
diff --git a/core/tx_list_test.go b/core/tx_list_test.go
index 83f5df7719..80b8c1ef32 100644
--- a/core/tx_list_test.go
+++ b/core/tx_list_test.go
@@ -60,11 +60,15 @@ func BenchmarkTxListAdd(b *testing.B) {
 	for i := 0; i < len(txs); i++ {
 		txs[i] = transaction(uint64(i), 0, key)
 	}
+
 	// Insert the transactions in a random order
 	priceLimit := uint256.NewInt(DefaultTxPoolConfig.PriceLimit)
 	b.ResetTimer()
+	b.ReportAllocs()
+
 	for i := 0; i < b.N; i++ {
 		list := newTxList(true)
+
 		for _, v := range rand.Perm(len(txs)) {
 			list.Add(txs[v], DefaultTxPoolConfig.PriceBump)
 			list.Filter(priceLimit, DefaultTxPoolConfig.PriceBump)
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 7d6722f762..65b23a5198 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -255,8 +255,7 @@ type TxPool struct {
 
 	pending      map[common.Address]*txList // All currently processable transactions
 	pendingCount int
-	queue        map[common.Address]*txList // Queued but non-processable transactions
-	queueCount   int
+	queue        map[common.Address]*txList   // Queued but non-processable transactions
 	beats        map[common.Address]time.Time // Last heartbeat from each known account
 	all          *txLookup                    // All transactions to allow lookups
 	priced       *txPricedList                // All transactions sorted by price
@@ -600,61 +599,75 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if !pool.eip2718 && tx.Type() != types.LegacyTxType {
 		return ErrTxTypeNotSupported
 	}
+
 	// Reject dynamic fee transactions until EIP-1559 activates.
 	if !pool.eip1559 && tx.Type() == types.DynamicFeeTxType {
 		return ErrTxTypeNotSupported
 	}
+
 	// Reject transactions over defined size to prevent DOS attacks
 	if uint64(tx.Size()) > txMaxSize {
 		return ErrOversizedData
 	}
+
 	// Transactions can't be negative. This may never happen using RLP decoded
 	// transactions but may occur if you create a transaction using the RPC.
 	if tx.Value().Sign() < 0 {
 		return ErrNegativeValue
 	}
+
 	// Ensure the transaction doesn't exceed the current block limit gas.
 	if pool.currentMaxGas < tx.Gas() {
 		return ErrGasLimit
 	}
+
 	// Sanity check for extremely large numbers
 	gasFeeCap := tx.GasFeeCapRef()
 	if gasFeeCap.BitLen() > 256 {
 		return ErrFeeCapVeryHigh
 	}
+
 	if gasFeeCap.BitLen() > 256 {
 		return ErrTipVeryHigh
 	}
+
 	// Ensure gasFeeCap is greater than or equal to gasTipCap.
 	if tx.GasFeeCapIntCmp(gasFeeCap) < 0 {
 		return ErrTipAboveFeeCap
 	}
+
 	// Make sure the transaction is signed properly.
 	from, err := types.Sender(pool.signer, tx)
 	if err != nil {
 		return ErrInvalidSender
 	}
+
 	// Drop non-local transactions under our own minimal accepted gas price or tip
 	if !local && tx.GasTipCapIntCmp(pool.gasPrice) < 0 {
 		return ErrUnderpriced
 	}
+
 	// Ensure the transaction adheres to nonce ordering
 	if pool.currentState.GetNonce(from) > tx.Nonce() {
 		return ErrNonceTooLow
 	}
+
 	// Transactor should have enough funds to cover the costs
 	// cost == V + GP * GL
 	if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {
 		return ErrInsufficientFunds
 	}
+
 	// Ensure the transaction has more gas than the basic tx fee.
 	intrGas, err := IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, true, pool.istanbul)
 	if err != nil {
 		return err
 	}
+
 	if tx.Gas() < intrGas {
 		return ErrIntrinsicGas
 	}
+
 	return nil
 }
 
@@ -1360,8 +1373,10 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 // invalidated transactions (low nonce, low balance) are deleted.
 func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Transaction {
 	// Track the promoted transactions to broadcast them at once
-	var promoted []*types.Transaction
-	var balance *uint256.Int
+	var (
+		promoted []*types.Transaction
+		balance  *uint256.Int
+	)
 
 	// Iterate over all accounts and promote any executable transactions
 	for _, addr := range accounts {
@@ -1444,7 +1459,9 @@ func (pool *TxPool) truncatePending() {
 	// Assemble a spam order to penalize large transactors first
 	spammers := make([]pair, 0, 8)
 	count := 0
+
 	var ok bool
+
 	for addr, list := range pool.pending {
 		// Only evict transactions from high rollers
 		listLen = len(list.txs.items)
@@ -1452,8 +1469,9 @@ func (pool *TxPool) truncatePending() {
 			if _, ok = pool.locals.accounts[addr]; !ok {
 				continue
 			}
-			// todo: use slice and sort it once
+
 			count++
+
 			spammers = append(spammers, pair{addr, int64(listLen)})
 		}
 	}
@@ -1471,13 +1489,17 @@ func (pool *TxPool) truncatePending() {
 		offender, spammers = spammers[len(spammers)-1].address, spammers[:len(spammers)-1]
 		offenders = append(offenders, offender)
 
+		var threshold int
+
 		// Equalize balances until all the same or below threshold
 		if len(offenders) > 1 {
 			// Calculate the equalization threshold for all current offenders
-			threshold := len(pool.pending[offender].txs.items)
+			threshold = len(pool.pending[offender].txs.items)
 
-			var list *txList
-			var hash common.Hash
+			var (
+				list *txList
+				hash common.Hash
+			)
 
 			// Iteratively reduce all offenders until below limit or threshold reached
 			for pending > pool.config.GlobalSlots && pool.pending[offenders[len(offenders)-2]].Len() > threshold {
@@ -1510,8 +1532,10 @@ func (pool *TxPool) truncatePending() {
 
 	// If still above threshold, reduce to limit or min allowance
 	if pending > pool.config.GlobalSlots && len(offenders) > 0 {
-		var list *txList
-		var hash common.Hash
+		var (
+			list *txList
+			hash common.Hash
+		)
 
 		for pending > pool.config.GlobalSlots && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > pool.config.AccountSlots {
 			for _, addr := range offenders {
@@ -1530,9 +1554,11 @@ func (pool *TxPool) truncatePending() {
 				pool.priced.Removed(len(caps))
 
 				pendingGauge.Dec(int64(len(caps)))
+
 				if _, ok = pool.locals.accounts[addr]; ok {
 					localGauge.Dec(int64(len(caps)))
 				}
+
 				pending--
 			}
 		}
diff --git a/core/types/transaction.go b/core/types/transaction.go
index aaf4631047..ed5e5cec35 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -281,6 +281,10 @@ func (tx *Transaction) GasTipCapUint() *uint256.Int {
 // GasFeeCap returns the fee cap per gas of the transaction.
 func (tx *Transaction) GasFeeCap() *big.Int    { return new(big.Int).Set(tx.inner.gasFeeCap()) }
 func (tx *Transaction) GasFeeCapRef() *big.Int { return tx.inner.gasFeeCap() }
+func (tx *Transaction) GasFeeCapUint() *uint256.Int {
+	b, _ := uint256.FromBig(tx.inner.gasFeeCap())
+	return b
+}
 
 // Value returns the ether amount of the transaction.
 func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }

From fead121d3acc2ae8c0f9f92122f2402dc34a4e28 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 15:42:38 +0400
Subject: [PATCH 27/96] fix gas calculation

---
 core/tx_pool.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 65b23a5198..681aa66b61 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -627,12 +627,13 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		return ErrFeeCapVeryHigh
 	}
 
-	if gasFeeCap.BitLen() > 256 {
+	gasTipCap := tx.GasTipCapRef()
+	if gasTipCap.BitLen() > 256 {
 		return ErrTipVeryHigh
 	}
 
 	// Ensure gasFeeCap is greater than or equal to gasTipCap.
-	if tx.GasFeeCapIntCmp(gasFeeCap) < 0 {
+	if tx.GasFeeCapIntCmp(gasTipCap) < 0 {
 		return ErrTipAboveFeeCap
 	}
 

From 0eb1bf9460e7e04aff27c3458d1ee9c4a0ef1c81 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 18:11:22 +0400
Subject: [PATCH 28/96] fix

---
 core/tx_list.go           | 35 ++++++++++++-----------------------
 core/tx_pool.go           |  5 +++--
 core/types/transaction.go | 10 ++++++++++
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index b5d8689191..a63bef46e9 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -28,7 +28,6 @@ import (
 	"github.com/holiman/uint256"
 
 	"github.com/ethereum/go-ethereum/common"
-	cmath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
@@ -287,43 +286,31 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 		if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 {
 			return false, nil
 		}
-
-		gasFeeCap := old.GasFeeCapUint()
-
-		priceBumpU := uint256.NewInt(priceBump)
-		priceBumpU = priceBumpU.Div(priceBumpU, cmath.U100)
-
 		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100
-		// thresholdFeeCap = oldFC  * (1 + priceBump/100)
-		a := cmath.U1.Clone().Add(cmath.U1, priceBumpU)
-		thresholdFeeCap := uint256.NewInt(0).Mul(a, gasFeeCap)
+		a := uint256.NewInt(100 + priceBump)
+		aFeeCap := uint256.NewInt(0).Mul(a, old.GasFeeCapUint())
+		aTip := a.Mul(a, old.GasTipCapUint())
 
 		// thresholdTip    = oldTip * (100 + priceBump) / 100
-		// thresholdTip    = oldTip * (1 + priceBump/100)
-		thresholdTip := a.Mul(a, gasFeeCap)
+		b := uint256.NewInt(100)
+		thresholdFeeCap := aFeeCap.Div(aFeeCap, b)
+		thresholdTip := aTip.Div(aTip, b)
 
 		// We have to ensure that both the new fee cap and tip are higher than the
 		// old ones as well as checking the percentage threshold to ensure that
 		// this is accurate for low (Wei-level) gas price replacements.
-		newGasFeeCap := tx.GasFeeCapUint()
-		newGasTipCap := tx.GasTipCapUint()
-
-		if newGasFeeCap.Lt(thresholdFeeCap) || newGasTipCap.Lt(thresholdTip) {
+		if tx.GasFeeCapUIntCmp(thresholdFeeCap) < 0 || tx.GasTipCapUIntCmp(thresholdTip) < 0 {
 			return false, nil
 		}
 	}
-
 	// Otherwise overwrite the old transaction with the current one
 	l.txs.Put(tx)
-
-	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Lt(cost) {
+	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Cmp(cost) < 0 {
 		l.costcap = cost
 	}
-
 	if gas := tx.Gas(); l.gascap < gas {
 		l.gascap = gas
 	}
-
 	return true, old
 }
 
@@ -345,7 +332,7 @@ func (l *txList) Forward(threshold uint64) types.Transactions {
 // the newly invalidated transactions.
 func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transactions, types.Transactions) {
 	// If all transactions are below the threshold, short circuit
-	if cmath.U256LTE(l.costcap, costLimit) && l.gascap <= gasLimit {
+	if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit {
 		return nil, nil
 	}
 
@@ -354,7 +341,9 @@ func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transact
 
 	// Filter out all the transactions above the account's funds
 	removed := l.txs.Filter(func(tx *types.Transaction) bool {
-		return tx.Gas() > gasLimit || tx.CostUint().Gt(costLimit)
+		// SUSP!
+		cost, _ := uint256.FromBig(tx.Cost())
+		return tx.Gas() > gasLimit || cost.Cmp(costLimit) > 0
 	})
 
 	if len(removed) == 0 {
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 681aa66b61..046f60b099 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -1376,9 +1376,10 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Trans
 	// Track the promoted transactions to broadcast them at once
 	var (
 		promoted []*types.Transaction
-		balance  *uint256.Int
 	)
 
+	balance := uint256.NewInt(0)
+
 	// Iterate over all accounts and promote any executable transactions
 	for _, addr := range accounts {
 		list := pool.queue[addr]
@@ -1393,7 +1394,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Trans
 		}
 		log.Trace("Removed old queued transactions", "count", len(forwards))
 		// Drop all transactions that are too costly (low balance or out of gas)
-		balance, _ = uint256.FromBig(pool.currentState.GetBalance(addr))
+		balance.SetFromBig(pool.currentState.GetBalance(addr))
 		drops, _ := list.Filter(balance, pool.currentMaxGas)
 		for _, tx := range drops {
 			hash := tx.Hash()
diff --git a/core/types/transaction.go b/core/types/transaction.go
index ed5e5cec35..f5b6fe0c07 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -333,6 +333,11 @@ func (tx *Transaction) GasFeeCapIntCmp(other *big.Int) int {
 	return tx.inner.gasFeeCap().Cmp(other)
 }
 
+func (tx *Transaction) GasFeeCapUIntCmp(other *uint256.Int) int {
+	b, _ := uint256.FromBig(tx.inner.gasFeeCap())
+	return b.Cmp(other)
+}
+
 // GasTipCapCmp compares the gasTipCap of two transactions.
 func (tx *Transaction) GasTipCapCmp(other *Transaction) int {
 	return tx.inner.gasTipCap().Cmp(other.inner.gasTipCap())
@@ -343,6 +348,11 @@ func (tx *Transaction) GasTipCapIntCmp(other *big.Int) int {
 	return tx.inner.gasTipCap().Cmp(other)
 }
 
+func (tx *Transaction) GasTipCapUIntCmp(other *uint256.Int) int {
+	b, _ := uint256.FromBig(tx.inner.gasTipCap())
+	return b.Cmp(other)
+}
+
 // EffectiveGasTip returns the effective miner gasTipCap for the given base fee.
 // Note: if the effective gasTipCap is negative, this method returns both error
 // the actual negative value, _and_ ErrGasFeeCapTooLow

From 3ff152b08d4f2de221d803212897ae821100fe6a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 19:21:01 +0400
Subject: [PATCH 29/96] green tests

---
 core/tx_list.go |  1 -
 core/tx_pool.go | 32 +++++++++++++++++++-------------
 2 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index a63bef46e9..9027e0cfff 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -341,7 +341,6 @@ func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transact
 
 	// Filter out all the transactions above the account's funds
 	removed := l.txs.Filter(func(tx *types.Transaction) bool {
-		// SUSP!
 		cost, _ := uint256.FromBig(tx.Cost())
 		return tx.Gas() > gasLimit || cost.Cmp(costLimit) > 0
 	})
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 046f60b099..b351d0ce52 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -18,7 +18,6 @@ package core
 
 import (
 	"errors"
-	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -1195,12 +1194,8 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 	defer func(t0 time.Time) {
 		reorgDurationTimer.Update(time.Since(t0))
 	}(time.Now())
-	defer close(done)
 
-	t := time.Now()
-	defer func() {
-		fmt.Println(time.Since(t))
-	}()
+	defer close(done)
 
 	var promoteAddrs []common.Address
 	if dirtyAccounts != nil && reset == nil {
@@ -1468,7 +1463,7 @@ func (pool *TxPool) truncatePending() {
 		// Only evict transactions from high rollers
 		listLen = len(list.txs.items)
 		if uint64(listLen) > pool.config.AccountSlots {
-			if _, ok = pool.locals.accounts[addr]; !ok {
+			if _, ok = pool.locals.accounts[addr]; ok {
 				continue
 			}
 
@@ -1477,13 +1472,17 @@ func (pool *TxPool) truncatePending() {
 			spammers = append(spammers, pair{addr, int64(listLen)})
 		}
 	}
+
 	// Gradually drop transactions from offenders
 	offenders := make([]common.Address, 0, len(spammers))
 	sort.Slice(spammers, func(i, j int) bool {
 		return spammers[i].value < spammers[j].value
 	})
 
-	var offender common.Address
+	var (
+		offender common.Address
+		caps     types.Transactions
+	)
 
 	// todo: metrics: spammers, offenders, total loops
 	for len(spammers) != 0 && pending > pool.config.GlobalSlots {
@@ -1508,7 +1507,7 @@ func (pool *TxPool) truncatePending() {
 				for i := 0; i < len(offenders)-1; i++ {
 					list = pool.pending[offenders[i]]
 
-					caps := list.Cap(len(list.txs.items) - 1)
+					caps = list.Cap(len(list.txs.items) - 1)
 					for _, tx := range caps {
 						// Drop the transaction from the global pools too
 						hash = tx.Hash()
@@ -1587,16 +1586,23 @@ func (pool *TxPool) truncateQueue() {
 	}
 	sort.Sort(addresses)
 
+	var (
+		tx   *types.Transaction
+		txs  types.Transactions
+		list *txList
+		addr addressByHeartbeat
+	)
+
 	// Drop transactions until the total is below the limit or only locals remain
 	for drop := queued - pool.config.GlobalQueue; drop > 0 && len(addresses) > 0; {
-		addr := addresses[len(addresses)-1]
-		list := pool.queue[addr.address]
+		addr = addresses[len(addresses)-1]
+		list = pool.queue[addr.address]
 
 		addresses = addresses[:len(addresses)-1]
 
 		// Drop all transactions if they are less than the overflow
 		if size := uint64(list.Len()); size <= drop {
-			for _, tx := range list.Flatten() {
+			for _, tx = range list.Flatten() {
 				pool.removeTx(tx.Hash(), true)
 			}
 			drop -= size
@@ -1604,7 +1610,7 @@ func (pool *TxPool) truncateQueue() {
 			continue
 		}
 		// Otherwise drop only last few transactions
-		txs := list.Flatten()
+		txs = list.Flatten()
 		for i := len(txs) - 1; i >= 0 && drop > 0; i-- {
 			pool.removeTx(txs[i].Hash(), true)
 			drop--

From 18585a80858951df8f3a59fd044fdbdac1984f3d Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 19:22:07 +0400
Subject: [PATCH 30/96] linters

---
 core/tx_list.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/tx_list.go b/core/tx_list.go
index 9027e0cfff..f1677cef68 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -303,14 +303,18 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 			return false, nil
 		}
 	}
+
 	// Otherwise overwrite the old transaction with the current one
 	l.txs.Put(tx)
+
 	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Cmp(cost) < 0 {
 		l.costcap = cost
 	}
+
 	if gas := tx.Gas(); l.gascap < gas {
 		l.gascap = gas
 	}
+
 	return true, old
 }
 

From a1e1a1f29d0111544cbad1c654bb27d8e42ca9f5 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 20 Oct 2022 19:47:18 +0400
Subject: [PATCH 31/96] prettify

---
 core/tx_list.go | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index f1677cef68..4159297eb9 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -28,6 +28,7 @@ import (
 	"github.com/holiman/uint256"
 
 	"github.com/ethereum/go-ethereum/common"
+	cmath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
@@ -286,15 +287,19 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 		if old.GasFeeCapCmp(tx) >= 0 || old.GasTipCapCmp(tx) >= 0 {
 			return false, nil
 		}
-		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100
-		a := uint256.NewInt(100 + priceBump)
-		aFeeCap := uint256.NewInt(0).Mul(a, old.GasFeeCapUint())
-		aTip := a.Mul(a, old.GasTipCapUint())
-
-		// thresholdTip    = oldTip * (100 + priceBump) / 100
-		b := uint256.NewInt(100)
-		thresholdFeeCap := aFeeCap.Div(aFeeCap, b)
-		thresholdTip := aTip.Div(aTip, b)
+
+		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100 = oldFC  * (1 + priceBump/100) = oldFC + oldFC*priceBump/100)
+		gasFeeCap := old.GasFeeCapUint()
+		priceBumpU := uint256.NewInt(priceBump)
+		priceBumpFC := uint256.NewInt(0).Mul(gasFeeCap, priceBumpU)
+		priceBumpFC = priceBumpFC.Div(priceBumpFC, cmath.U100)
+		thresholdFeeCap := gasFeeCap.Add(gasFeeCap, priceBumpFC)
+
+		// thresholdTip    = oldTip * (100 + priceBump) / 100 = oldTip * (1 + priceBump/100) = oldTip + oldTip*priceBump/100
+		gasTipCap := old.GasTipCapUint()
+		priceBumpTC := uint256.NewInt(0).Mul(gasTipCap, priceBumpU)
+		priceBumpTC = priceBumpTC.Div(priceBumpTC, cmath.U100)
+		thresholdTip := gasTipCap.Add(gasTipCap, priceBumpTC)
 
 		// We have to ensure that both the new fee cap and tip are higher than the
 		// old ones as well as checking the percentage threshold to ensure that

From 6bc8883ee9d87114e5273fcece0a4a4fecfbe13b Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Fri, 21 Oct 2022 13:36:02 +0400
Subject: [PATCH 32/96] allocate less

---
 cmd/evm/internal/t8ntool/transaction.go |   3 +-
 core/tx_list.go                         |  32 +++--
 core/tx_pool.go                         | 166 +++++++++++++++++-------
 core/tx_pool_test.go                    |   2 +
 core/types/access_list_tx.go            |  65 ++++++++--
 core/types/dynamic_fee_tx.go            |  71 ++++++++--
 core/types/legacy_tx.go                 |  60 +++++++--
 core/types/transaction.go               |  46 +++----
 8 files changed, 320 insertions(+), 125 deletions(-)

diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go
index 6f1c964ada..cf2039b66c 100644
--- a/cmd/evm/internal/t8ntool/transaction.go
+++ b/cmd/evm/internal/t8ntool/transaction.go
@@ -24,6 +24,8 @@ import (
 	"os"
 	"strings"
 
+	"gopkg.in/urfave/cli.v1"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
@@ -32,7 +34,6 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/tests"
-	"gopkg.in/urfave/cli.v1"
 )
 
 type result struct {
diff --git a/core/tx_list.go b/core/tx_list.go
index 4159297eb9..8b72764e3b 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -288,23 +288,20 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 			return false, nil
 		}
 
-		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100 = oldFC  * (1 + priceBump/100) = oldFC + oldFC*priceBump/100)
-		gasFeeCap := old.GasFeeCapUint()
-		priceBumpU := uint256.NewInt(priceBump)
-		priceBumpFC := uint256.NewInt(0).Mul(gasFeeCap, priceBumpU)
-		priceBumpFC = priceBumpFC.Div(priceBumpFC, cmath.U100)
-		thresholdFeeCap := gasFeeCap.Add(gasFeeCap, priceBumpFC)
-
-		// thresholdTip    = oldTip * (100 + priceBump) / 100 = oldTip * (1 + priceBump/100) = oldTip + oldTip*priceBump/100
-		gasTipCap := old.GasTipCapUint()
-		priceBumpTC := uint256.NewInt(0).Mul(gasTipCap, priceBumpU)
-		priceBumpTC = priceBumpTC.Div(priceBumpTC, cmath.U100)
-		thresholdTip := gasTipCap.Add(gasTipCap, priceBumpTC)
+		// thresholdFeeCap = oldFC  * (100 + priceBump) / 100
+		a := uint256.NewInt(100 + priceBump)
+		aFeeCap := uint256.NewInt(0).Mul(a, old.GasFeeCapUint())
+		aTip := a.Mul(a, old.GasTipCapUint())
+
+		// thresholdTip    = oldTip * (100 + priceBump) / 100
+		b := cmath.U100
+		thresholdFeeCap := aFeeCap.Div(aFeeCap, b)
+		thresholdTip := aTip.Div(aTip, b)
 
 		// We have to ensure that both the new fee cap and tip are higher than the
 		// old ones as well as checking the percentage threshold to ensure that
 		// this is accurate for low (Wei-level) gas price replacements.
-		if tx.GasFeeCapUIntCmp(thresholdFeeCap) < 0 || tx.GasTipCapUIntCmp(thresholdTip) < 0 {
+		if tx.GasFeeCapUIntLt(thresholdFeeCap) || tx.GasTipCapUIntLt(thresholdTip) {
 			return false, nil
 		}
 	}
@@ -312,7 +309,7 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 	// Otherwise overwrite the old transaction with the current one
 	l.txs.Put(tx)
 
-	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Cmp(cost) < 0 {
+	if cost := tx.CostUint(); l.costcap == nil || l.costcap.Lt(cost) {
 		l.costcap = cost
 	}
 
@@ -341,7 +338,7 @@ func (l *txList) Forward(threshold uint64) types.Transactions {
 // the newly invalidated transactions.
 func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transactions, types.Transactions) {
 	// If all transactions are below the threshold, short circuit
-	if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit {
+	if cmath.U256LTE(l.costcap, costLimit) && l.gascap <= gasLimit {
 		return nil, nil
 	}
 
@@ -349,9 +346,10 @@ func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transact
 	l.gascap = gasLimit
 
 	// Filter out all the transactions above the account's funds
+	var cost *uint256.Int
 	removed := l.txs.Filter(func(tx *types.Transaction) bool {
-		cost, _ := uint256.FromBig(tx.Cost())
-		return tx.Gas() > gasLimit || cost.Cmp(costLimit) > 0
+		cost, _ = uint256.FromBig(tx.Cost())
+		return tx.Gas() > gasLimit || cost.Gt(costLimit)
 	})
 
 	if len(removed) == 0 {
diff --git a/core/tx_pool.go b/core/tx_pool.go
index b351d0ce52..0fb8871d9e 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -232,14 +232,15 @@ func (config *TxPoolConfig) sanitize() TxPoolConfig {
 // current state) and future transactions. Transactions move between those
 // two states over time as they are received and processed.
 type TxPool struct {
-	config      TxPoolConfig
-	chainconfig *params.ChainConfig
-	chain       blockChain
-	gasPrice    *big.Int
-	txFeed      event.Feed
-	scope       event.SubscriptionScope
-	signer      types.Signer
-	mu          sync.RWMutex
+	config       TxPoolConfig
+	chainconfig  *params.ChainConfig
+	chain        blockChain
+	gasPrice     *big.Int
+	gasPriceUint *uint256.Int
+	txFeed       event.Feed
+	scope        event.SubscriptionScope
+	signer       types.Signer
+	mu           sync.RWMutex
 
 	istanbul bool // Fork indicator whether we are in the istanbul stage.
 	eip2718  bool // Fork indicator whether we are using EIP-2718 type transactions.
@@ -302,6 +303,7 @@ func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain block
 		reorgShutdownCh: make(chan struct{}),
 		initDoneCh:      make(chan struct{}),
 		gasPrice:        new(big.Int).SetUint64(config.PriceLimit),
+		gasPriceUint:    uint256.NewInt(config.PriceLimit),
 	}
 
 	pool.locals = newAccountSet(pool.signer)
@@ -449,6 +451,13 @@ func (pool *TxPool) GasPrice() *big.Int {
 	return new(big.Int).Set(pool.gasPrice)
 }
 
+func (pool *TxPool) GasPriceUint256() *uint256.Int {
+	pool.mu.RLock()
+	defer pool.mu.RUnlock()
+
+	return pool.gasPriceUint.Clone()
+}
+
 // SetGasPrice updates the minimum price required by the transaction pool for a
 // new transaction, and drops all transactions below this threshold.
 func (pool *TxPool) SetGasPrice(price *big.Int) {
@@ -457,6 +466,13 @@ func (pool *TxPool) SetGasPrice(price *big.Int) {
 
 	old := pool.gasPrice
 	pool.gasPrice = price
+
+	if pool.gasPriceUint == nil {
+		pool.gasPriceUint, _ = uint256.FromBig(price)
+	} else {
+		pool.gasPriceUint.SetFromBig(price)
+	}
+
 	// if the min miner fee increased, remove transactions below the new threshold
 	if price.Cmp(old) > 0 {
 		// pool.priced is sorted by GasFeeCap, so we have to iterate through pool.all instead
@@ -464,6 +480,7 @@ func (pool *TxPool) SetGasPrice(price *big.Int) {
 		for _, tx := range drop {
 			pool.removeTx(tx.Hash(), false)
 		}
+
 		pool.priced.Removed(len(drop))
 	}
 
@@ -626,13 +643,15 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		return ErrFeeCapVeryHigh
 	}
 
+	// do NOT use uint256 here. results vs *big.Int are different
 	gasTipCap := tx.GasTipCapRef()
 	if gasTipCap.BitLen() > 256 {
 		return ErrTipVeryHigh
 	}
 
 	// Ensure gasFeeCap is greater than or equal to gasTipCap.
-	if tx.GasFeeCapIntCmp(gasTipCap) < 0 {
+	gasTipCapU, _ := uint256.FromBig(gasTipCap)
+	if tx.GasFeeCapUIntLt(gasTipCapU) {
 		return ErrTipAboveFeeCap
 	}
 
@@ -643,7 +662,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	}
 
 	// Drop non-local transactions under our own minimal accepted gas price or tip
-	if !local && tx.GasTipCapIntCmp(pool.gasPrice) < 0 {
+	if !local && tx.GasTipCapUIntLt(pool.gasPriceUint) {
 		return ErrUnderpriced
 	}
 
@@ -700,7 +719,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 	if uint64(pool.all.Slots()+numSlots(tx)) > pool.config.GlobalSlots+pool.config.GlobalQueue {
 		// If the new transaction is underpriced, don't accept it
 		if !isLocal && pool.priced.Underpriced(tx) {
-			log.Trace("Discarding underpriced transaction", "hash", hash, "gasTipCap", tx.GasTipCap(), "gasFeeCap", tx.GasFeeCap())
+			log.Trace("Discarding underpriced transaction", "hash", hash, "gasTipCap", tx.GasTipCapUint(), "gasFeeCap", tx.GasFeeCapUint())
 			underpricedTxMeter.Mark(1)
 			return false, ErrUnderpriced
 		}
@@ -728,7 +747,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 		pool.changesSinceReorg += len(drop)
 		// Kick out the underpriced remote transactions.
 		for _, tx := range drop {
-			log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "gasTipCap", tx.GasTipCap(), "gasFeeCap", tx.GasFeeCap())
+			log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "gasTipCap", tx.GasTipCapUint(), "gasFeeCap", tx.GasFeeCapUint())
 			underpricedTxMeter.Mark(1)
 			pool.removeTx(tx.Hash(), false)
 		}
@@ -1370,62 +1389,92 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Transaction {
 	// Track the promoted transactions to broadcast them at once
 	var (
-		promoted []*types.Transaction
+		promoted    []*types.Transaction
+		promotedLen int
+		forwards    types.Transactions
+		forwardsLen int
+		caps        types.Transactions
+		capsLen     int
+		drops       types.Transactions
+		dropsLen    int
+		list        *txList
+		hash        common.Hash
+		readies     types.Transactions
+		readiesLen  int
 	)
 
 	balance := uint256.NewInt(0)
 
 	// Iterate over all accounts and promote any executable transactions
 	for _, addr := range accounts {
-		list := pool.queue[addr]
+		list = pool.queue[addr]
 		if list == nil {
 			continue // Just in case someone calls with a non existing account
 		}
+
 		// Drop all transactions that are deemed too old (low nonce)
-		forwards := list.Forward(pool.currentState.GetNonce(addr))
+		forwards = list.Forward(pool.currentState.GetNonce(addr))
+		forwardsLen = len(forwards)
+
 		for _, tx := range forwards {
-			hash := tx.Hash()
+			hash = tx.Hash()
 			pool.all.Remove(hash)
 		}
-		log.Trace("Removed old queued transactions", "count", len(forwards))
+
+		log.Trace("Removed old queued transactions", "count", forwardsLen)
+
 		// Drop all transactions that are too costly (low balance or out of gas)
 		balance.SetFromBig(pool.currentState.GetBalance(addr))
-		drops, _ := list.Filter(balance, pool.currentMaxGas)
+
+		drops, _ = list.Filter(balance, pool.currentMaxGas)
+		dropsLen = len(drops)
+
 		for _, tx := range drops {
-			hash := tx.Hash()
+			hash = tx.Hash()
 			pool.all.Remove(hash)
 		}
-		log.Trace("Removed unpayable queued transactions", "count", len(drops))
-		queuedNofundsMeter.Mark(int64(len(drops)))
+
+		log.Trace("Removed unpayable queued transactions", "count", dropsLen)
+		queuedNofundsMeter.Mark(int64(dropsLen))
 
 		// Gather all executable transactions and promote them
-		readies := list.Ready(pool.pendingNonces.get(addr))
+		readies = list.Ready(pool.pendingNonces.get(addr))
+		readiesLen = len(readies)
+
 		for _, tx := range readies {
-			hash := tx.Hash()
+			hash = tx.Hash()
 			if pool.promoteTx(addr, hash, tx) {
 				promoted = append(promoted, tx)
 			}
 		}
-		log.Trace("Promoted queued transactions", "count", len(promoted))
-		queuedGauge.Dec(int64(len(readies)))
+
+		log.Trace("Promoted queued transactions", "count", promotedLen)
+		queuedGauge.Dec(int64(readiesLen))
 
 		// Drop all transactions over the allowed limit
-		var caps types.Transactions
 		if !pool.locals.contains(addr) {
 			caps = list.Cap(int(pool.config.AccountQueue))
+			capsLen = len(caps)
+
 			for _, tx := range caps {
-				hash := tx.Hash()
+				hash = tx.Hash()
 				pool.all.Remove(hash)
+
 				log.Trace("Removed cap-exceeding queued transaction", "hash", hash)
 			}
-			queuedRateLimitMeter.Mark(int64(len(caps)))
+
+			queuedRateLimitMeter.Mark(int64(capsLen))
 		}
+
 		// Mark all the items dropped as removed
-		pool.priced.Removed(len(forwards) + len(drops) + len(caps))
-		queuedGauge.Dec(int64(len(forwards) + len(drops) + len(caps)))
+		pool.priced.Removed(forwardsLen + dropsLen + capsLen)
+
+		queuedGauge.Dec(int64(forwardsLen + dropsLen + capsLen))
+
 		if pool.locals.contains(addr) {
-			localGauge.Dec(int64(len(forwards) + len(drops) + len(caps)))
+			localGauge.Dec(int64(forwardsLen + dropsLen + capsLen))
 		}
+
 		// Delete the entire queue entry if it became empty.
 		if list.Empty() {
 			delete(pool.queue, addr)
@@ -1542,7 +1591,7 @@ func (pool *TxPool) truncatePending() {
 			for _, addr := range offenders {
 				list = pool.pending[addr]
 
-				caps := list.Cap(len(list.txs.items) - 1)
+				caps = list.Cap(len(list.txs.items) - 1)
 				for _, tx := range caps {
 					// Drop the transaction from the global pools too
 					hash = tx.Hash()
@@ -1591,6 +1640,7 @@ func (pool *TxPool) truncateQueue() {
 		txs  types.Transactions
 		list *txList
 		addr addressByHeartbeat
+		size uint64
 	)
 
 	// Drop transactions until the total is below the limit or only locals remain
@@ -1601,7 +1651,7 @@ func (pool *TxPool) truncateQueue() {
 		addresses = addresses[:len(addresses)-1]
 
 		// Drop all transactions if they are less than the overflow
-		if size := uint64(list.Len()); size <= drop {
+		if size = uint64(list.Len()); size <= drop {
 			for _, tx = range list.Flatten() {
 				pool.removeTx(tx.Hash(), true)
 			}
@@ -1629,51 +1679,77 @@ func (pool *TxPool) truncateQueue() {
 func (pool *TxPool) demoteUnexecutables() {
 	balance := uint256.NewInt(0)
 
+	var (
+		olds        types.Transactions
+		oldsLen     int
+		hash        common.Hash
+		drops       types.Transactions
+		dropsLen    int
+		invalids    types.Transactions
+		invalidsLen int
+		gapped      types.Transactions
+		gappedLen   int
+	)
+
 	// Iterate over all accounts and demote any non-executable transactions
 	for addr, list := range pool.pending {
 		nonce := pool.currentState.GetNonce(addr)
 
 		// Drop all transactions that are deemed too old (low nonce)
-		olds := list.Forward(nonce)
+		olds = list.Forward(nonce)
+		oldsLen = len(olds)
+
 		for _, tx := range olds {
-			hash := tx.Hash()
+			hash = tx.Hash()
 			pool.all.Remove(hash)
 			log.Trace("Removed old pending transaction", "hash", hash)
 		}
 		// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
 		balance.SetFromBig(pool.currentState.GetBalance(addr))
-		drops, invalids := list.Filter(balance, pool.currentMaxGas)
+		drops, invalids = list.Filter(balance, pool.currentMaxGas)
+		dropsLen = len(drops)
+		invalidsLen = len(invalids)
+
 		for _, tx := range drops {
-			hash := tx.Hash()
+			hash = tx.Hash()
+
 			log.Trace("Removed unpayable pending transaction", "hash", hash)
+
 			pool.all.Remove(hash)
 		}
-		pendingNofundsMeter.Mark(int64(len(drops)))
+
+		pendingNofundsMeter.Mark(int64(dropsLen))
 
 		for _, tx := range invalids {
-			hash := tx.Hash()
+			hash = tx.Hash()
+
 			log.Trace("Demoting pending transaction", "hash", hash)
 
 			// Internal shuffle shouldn't touch the lookup set.
 			pool.enqueueTx(hash, tx, false, false)
 		}
-		pendingGauge.Dec(int64(len(olds) + len(drops) + len(invalids)))
+
+		pendingGauge.Dec(int64(oldsLen + dropsLen + invalidsLen))
+
 		if pool.locals.contains(addr) {
-			localGauge.Dec(int64(len(olds) + len(drops) + len(invalids)))
+			localGauge.Dec(int64(oldsLen + dropsLen + invalidsLen))
 		}
 		// If there's a gap in front, alert (should never happen) and postpone all transactions
 		if list.Len() > 0 && list.txs.Get(nonce) == nil {
-			gapped := list.Cap(0)
+			gapped = list.Cap(0)
+			gappedLen = len(gapped)
+
 			for _, tx := range gapped {
-				hash := tx.Hash()
+				hash = tx.Hash()
 				log.Error("Demoting invalidated transaction", "hash", hash)
 
 				// Internal shuffle shouldn't touch the lookup set.
 				pool.enqueueTx(hash, tx, false, false)
 			}
-			pendingGauge.Dec(int64(len(gapped)))
+
+			pendingGauge.Dec(int64(gappedLen))
 			// This might happen in a reorg, so log it to the metering
-			blockReorgInvalidatedTx.Mark(int64(len(gapped)))
+			blockReorgInvalidatedTx.Mark(int64(gappedLen))
 		}
 		// Delete the entire pending entry if it became empty.
 		if list.Empty() {
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index a8f5dc090c..5b421b9fe1 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -32,6 +32,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/holiman/uint256"
 	"gonum.org/v1/gonum/floats"
 	"gonum.org/v1/gonum/stat"
 	"pgregory.net/rapid"
@@ -326,6 +327,7 @@ func TestInvalidTransactions(t *testing.T) {
 
 	tx = transaction(1, 100000, key)
 	pool.gasPrice = big.NewInt(1000)
+	pool.gasPriceUint = uint256.NewInt(1000)
 	if err := pool.AddRemote(tx); err != ErrUnderpriced {
 		t.Error("expected", ErrUnderpriced, "got", err)
 	}
diff --git a/core/types/access_list_tx.go b/core/types/access_list_tx.go
index 8ad5e739e9..509f86b622 100644
--- a/core/types/access_list_tx.go
+++ b/core/types/access_list_tx.go
@@ -19,6 +19,8 @@ package types
 import (
 	"math/big"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -44,15 +46,16 @@ func (al AccessList) StorageKeys() int {
 
 // AccessListTx is the data of EIP-2930 access list transactions.
 type AccessListTx struct {
-	ChainID    *big.Int        // destination chain ID
-	Nonce      uint64          // nonce of sender account
-	GasPrice   *big.Int        // wei per gas
-	Gas        uint64          // gas limit
-	To         *common.Address `rlp:"nil"` // nil means contract creation
-	Value      *big.Int        // wei amount
-	Data       []byte          // contract invocation input data
-	AccessList AccessList      // EIP-2930 access list
-	V, R, S    *big.Int        // signature values
+	ChainID         *big.Int        // destination chain ID
+	Nonce           uint64          // nonce of sender account
+	GasPrice        *big.Int        // wei per gas
+	gasPriceUint256 *uint256.Int    // wei per gas
+	Gas             uint64          // gas limit
+	To              *common.Address `rlp:"nil"` // nil means contract creation
+	Value           *big.Int        // wei amount
+	Data            []byte          // contract invocation input data
+	AccessList      AccessList      // EIP-2930 access list
+	V, R, S         *big.Int        // signature values
 }
 
 // copy creates a deep copy of the transaction data and initializes all fields.
@@ -80,6 +83,12 @@ func (tx *AccessListTx) copy() TxData {
 	}
 	if tx.GasPrice != nil {
 		cpy.GasPrice.Set(tx.GasPrice)
+
+		if cpy.gasPriceUint256 != nil {
+			cpy.gasPriceUint256.Set(tx.gasPriceUint256)
+		} else {
+			cpy.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+		}
 	}
 	if tx.V != nil {
 		cpy.V.Set(tx.V)
@@ -100,11 +109,39 @@ func (tx *AccessListTx) accessList() AccessList { return tx.AccessList }
 func (tx *AccessListTx) data() []byte           { return tx.Data }
 func (tx *AccessListTx) gas() uint64            { return tx.Gas }
 func (tx *AccessListTx) gasPrice() *big.Int     { return tx.GasPrice }
-func (tx *AccessListTx) gasTipCap() *big.Int    { return tx.GasPrice }
-func (tx *AccessListTx) gasFeeCap() *big.Int    { return tx.GasPrice }
-func (tx *AccessListTx) value() *big.Int        { return tx.Value }
-func (tx *AccessListTx) nonce() uint64          { return tx.Nonce }
-func (tx *AccessListTx) to() *common.Address    { return tx.To }
+func (tx *AccessListTx) gasPriceU256() *uint256.Int {
+	if tx.gasPriceUint256 != nil {
+		return tx.gasPriceUint256
+	}
+
+	tx.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+
+	return tx.gasPriceUint256
+}
+
+func (tx *AccessListTx) gasTipCap() *big.Int { return tx.GasPrice }
+func (tx *AccessListTx) gasTipCapU256() *uint256.Int {
+	if tx.gasPriceUint256 != nil {
+		return tx.gasPriceUint256
+	}
+
+	tx.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+
+	return tx.gasPriceUint256
+}
+func (tx *AccessListTx) gasFeeCap() *big.Int { return tx.GasPrice }
+func (tx *AccessListTx) gasFeeCapU256() *uint256.Int {
+	if tx.gasPriceUint256 != nil {
+		return tx.gasPriceUint256
+	}
+
+	tx.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+
+	return tx.gasPriceUint256
+}
+func (tx *AccessListTx) value() *big.Int     { return tx.Value }
+func (tx *AccessListTx) nonce() uint64       { return tx.Nonce }
+func (tx *AccessListTx) to() *common.Address { return tx.To }
 
 func (tx *AccessListTx) rawSignatureValues() (v, r, s *big.Int) {
 	return tx.V, tx.R, tx.S
diff --git a/core/types/dynamic_fee_tx.go b/core/types/dynamic_fee_tx.go
index 53f246ea1f..532544d54e 100644
--- a/core/types/dynamic_fee_tx.go
+++ b/core/types/dynamic_fee_tx.go
@@ -19,19 +19,23 @@ package types
 import (
 	"math/big"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 )
 
 type DynamicFeeTx struct {
-	ChainID    *big.Int
-	Nonce      uint64
-	GasTipCap  *big.Int // a.k.a. maxPriorityFeePerGas
-	GasFeeCap  *big.Int // a.k.a. maxFeePerGas
-	Gas        uint64
-	To         *common.Address `rlp:"nil"` // nil means contract creation
-	Value      *big.Int
-	Data       []byte
-	AccessList AccessList
+	ChainID          *big.Int
+	Nonce            uint64
+	GasTipCap        *big.Int     // a.k.a. maxPriorityFeePerGas
+	gasTipCapUint256 *uint256.Int // a.k.a. maxPriorityFeePerGas
+	GasFeeCap        *big.Int     // a.k.a. maxFeePerGas
+	gasFeeCapUint256 *uint256.Int // a.k.a. maxFeePerGas
+	Gas              uint64
+	To               *common.Address `rlp:"nil"` // nil means contract creation
+	Value            *big.Int
+	Data             []byte
+	AccessList       AccessList
 
 	// Signature values
 	V *big.Int `json:"v" gencodec:"required"`
@@ -65,9 +69,21 @@ func (tx *DynamicFeeTx) copy() TxData {
 	}
 	if tx.GasTipCap != nil {
 		cpy.GasTipCap.Set(tx.GasTipCap)
+
+		if cpy.gasTipCapUint256 != nil {
+			cpy.gasTipCapUint256.Set(tx.gasTipCapUint256)
+		} else {
+			cpy.gasTipCapUint256, _ = uint256.FromBig(tx.GasTipCap)
+		}
 	}
 	if tx.GasFeeCap != nil {
 		cpy.GasFeeCap.Set(tx.GasFeeCap)
+
+		if cpy.gasFeeCapUint256 != nil {
+			cpy.gasFeeCapUint256.Set(tx.gasFeeCapUint256)
+		} else {
+			cpy.gasFeeCapUint256, _ = uint256.FromBig(tx.GasFeeCap)
+		}
 	}
 	if tx.V != nil {
 		cpy.V.Set(tx.V)
@@ -88,11 +104,38 @@ func (tx *DynamicFeeTx) accessList() AccessList { return tx.AccessList }
 func (tx *DynamicFeeTx) data() []byte           { return tx.Data }
 func (tx *DynamicFeeTx) gas() uint64            { return tx.Gas }
 func (tx *DynamicFeeTx) gasFeeCap() *big.Int    { return tx.GasFeeCap }
-func (tx *DynamicFeeTx) gasTipCap() *big.Int    { return tx.GasTipCap }
-func (tx *DynamicFeeTx) gasPrice() *big.Int     { return tx.GasFeeCap }
-func (tx *DynamicFeeTx) value() *big.Int        { return tx.Value }
-func (tx *DynamicFeeTx) nonce() uint64          { return tx.Nonce }
-func (tx *DynamicFeeTx) to() *common.Address    { return tx.To }
+func (tx *DynamicFeeTx) gasFeeCapU256() *uint256.Int {
+	if tx.gasFeeCapUint256 != nil {
+		return tx.gasFeeCapUint256
+	}
+
+	tx.gasFeeCapUint256, _ = uint256.FromBig(tx.GasFeeCap)
+
+	return tx.gasFeeCapUint256
+}
+func (tx *DynamicFeeTx) gasTipCap() *big.Int { return tx.GasTipCap }
+func (tx *DynamicFeeTx) gasTipCapU256() *uint256.Int {
+	if tx.gasTipCapUint256 != nil {
+		return tx.gasTipCapUint256
+	}
+
+	tx.gasTipCapUint256, _ = uint256.FromBig(tx.GasTipCap)
+
+	return tx.gasTipCapUint256
+}
+func (tx *DynamicFeeTx) gasPrice() *big.Int { return tx.GasFeeCap }
+func (tx *DynamicFeeTx) gasPriceU256() *uint256.Int {
+	if tx.gasFeeCapUint256 != nil {
+		return tx.gasTipCapUint256
+	}
+
+	tx.gasFeeCapUint256, _ = uint256.FromBig(tx.GasFeeCap)
+
+	return tx.gasFeeCapUint256
+}
+func (tx *DynamicFeeTx) value() *big.Int     { return tx.Value }
+func (tx *DynamicFeeTx) nonce() uint64       { return tx.Nonce }
+func (tx *DynamicFeeTx) to() *common.Address { return tx.To }
 
 func (tx *DynamicFeeTx) rawSignatureValues() (v, r, s *big.Int) {
 	return tx.V, tx.R, tx.S
diff --git a/core/types/legacy_tx.go b/core/types/legacy_tx.go
index cb86bed772..72fcd34fa5 100644
--- a/core/types/legacy_tx.go
+++ b/core/types/legacy_tx.go
@@ -19,18 +19,21 @@ package types
 import (
 	"math/big"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 )
 
 // LegacyTx is the transaction data of regular Ethereum transactions.
 type LegacyTx struct {
-	Nonce    uint64          // nonce of sender account
-	GasPrice *big.Int        // wei per gas
-	Gas      uint64          // gas limit
-	To       *common.Address `rlp:"nil"` // nil means contract creation
-	Value    *big.Int        // wei amount
-	Data     []byte          // contract invocation input data
-	V, R, S  *big.Int        // signature values
+	Nonce           uint64          // nonce of sender account
+	GasPrice        *big.Int        // wei per gas
+	gasPriceUint256 *uint256.Int    // wei per gas
+	Gas             uint64          // gas limit
+	To              *common.Address `rlp:"nil"` // nil means contract creation
+	Value           *big.Int        // wei amount
+	Data            []byte          // contract invocation input data
+	V, R, S         *big.Int        // signature values
 }
 
 // NewTransaction creates an unsigned legacy transaction.
@@ -77,6 +80,12 @@ func (tx *LegacyTx) copy() TxData {
 	}
 	if tx.GasPrice != nil {
 		cpy.GasPrice.Set(tx.GasPrice)
+
+		if cpy.gasPriceUint256 != nil {
+			cpy.gasPriceUint256.Set(tx.gasPriceUint256)
+		} else {
+			cpy.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+		}
 	}
 	if tx.V != nil {
 		cpy.V.Set(tx.V)
@@ -97,11 +106,38 @@ func (tx *LegacyTx) accessList() AccessList { return nil }
 func (tx *LegacyTx) data() []byte           { return tx.Data }
 func (tx *LegacyTx) gas() uint64            { return tx.Gas }
 func (tx *LegacyTx) gasPrice() *big.Int     { return tx.GasPrice }
-func (tx *LegacyTx) gasTipCap() *big.Int    { return tx.GasPrice }
-func (tx *LegacyTx) gasFeeCap() *big.Int    { return tx.GasPrice }
-func (tx *LegacyTx) value() *big.Int        { return tx.Value }
-func (tx *LegacyTx) nonce() uint64          { return tx.Nonce }
-func (tx *LegacyTx) to() *common.Address    { return tx.To }
+func (tx *LegacyTx) gasPriceU256() *uint256.Int {
+	if tx.gasPriceUint256 != nil {
+		return tx.gasPriceUint256
+	}
+
+	tx.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+
+	return tx.gasPriceUint256
+}
+func (tx *LegacyTx) gasTipCap() *big.Int { return tx.GasPrice }
+func (tx *LegacyTx) gasTipCapU256() *uint256.Int {
+	if tx.gasPriceUint256 != nil {
+		return tx.gasPriceUint256
+	}
+
+	tx.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+
+	return tx.gasPriceUint256
+}
+func (tx *LegacyTx) gasFeeCap() *big.Int { return tx.GasPrice }
+func (tx *LegacyTx) gasFeeCapU256() *uint256.Int {
+	if tx.gasPriceUint256 != nil {
+		return tx.gasPriceUint256
+	}
+
+	tx.gasPriceUint256, _ = uint256.FromBig(tx.GasPrice)
+
+	return tx.gasPriceUint256
+}
+func (tx *LegacyTx) value() *big.Int     { return tx.Value }
+func (tx *LegacyTx) nonce() uint64       { return tx.Nonce }
+func (tx *LegacyTx) to() *common.Address { return tx.To }
 
 func (tx *LegacyTx) rawSignatureValues() (v, r, s *big.Int) {
 	return tx.V, tx.R, tx.S
diff --git a/core/types/transaction.go b/core/types/transaction.go
index f5b6fe0c07..66330e3bfb 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -79,8 +79,11 @@ type TxData interface {
 	data() []byte
 	gas() uint64
 	gasPrice() *big.Int
+	gasPriceU256() *uint256.Int
 	gasTipCap() *big.Int
+	gasTipCapU256() *uint256.Int
 	gasFeeCap() *big.Int
+	gasFeeCapU256() *uint256.Int
 	value() *big.Int
 	nonce() uint64
 	to() *common.Address
@@ -267,28 +270,22 @@ func (tx *Transaction) AccessList() AccessList { return tx.inner.accessList() }
 func (tx *Transaction) Gas() uint64 { return tx.inner.gas() }
 
 // GasPrice returns the gas price of the transaction.
-func (tx *Transaction) GasPrice() *big.Int    { return new(big.Int).Set(tx.inner.gasPrice()) }
-func (tx *Transaction) GasPriceRef() *big.Int { return tx.inner.gasPrice() }
+func (tx *Transaction) GasPrice() *big.Int         { return new(big.Int).Set(tx.inner.gasPrice()) }
+func (tx *Transaction) GasPriceRef() *big.Int      { return tx.inner.gasPrice() }
+func (tx *Transaction) GasPriceUint() *uint256.Int { return tx.inner.gasPriceU256() }
 
 // GasTipCap returns the gasTipCap per gas of the transaction.
-func (tx *Transaction) GasTipCap() *big.Int    { return new(big.Int).Set(tx.inner.gasTipCap()) }
-func (tx *Transaction) GasTipCapRef() *big.Int { return tx.inner.gasTipCap() }
-func (tx *Transaction) GasTipCapUint() *uint256.Int {
-	b, _ := uint256.FromBig(tx.inner.gasTipCap())
-	return b
-}
+func (tx *Transaction) GasTipCap() *big.Int         { return new(big.Int).Set(tx.inner.gasTipCap()) }
+func (tx *Transaction) GasTipCapRef() *big.Int      { return tx.inner.gasTipCap() }
+func (tx *Transaction) GasTipCapUint() *uint256.Int { return tx.inner.gasTipCapU256() }
 
 // GasFeeCap returns the fee cap per gas of the transaction.
-func (tx *Transaction) GasFeeCap() *big.Int    { return new(big.Int).Set(tx.inner.gasFeeCap()) }
-func (tx *Transaction) GasFeeCapRef() *big.Int { return tx.inner.gasFeeCap() }
-func (tx *Transaction) GasFeeCapUint() *uint256.Int {
-	b, _ := uint256.FromBig(tx.inner.gasFeeCap())
-	return b
-}
+func (tx *Transaction) GasFeeCap() *big.Int         { return new(big.Int).Set(tx.inner.gasFeeCap()) }
+func (tx *Transaction) GasFeeCapRef() *big.Int      { return tx.inner.gasFeeCap() }
+func (tx *Transaction) GasFeeCapUint() *uint256.Int { return tx.inner.gasFeeCapU256() }
 
 // Value returns the ether amount of the transaction.
-func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.inner.value()) }
-
+func (tx *Transaction) Value() *big.Int    { return new(big.Int).Set(tx.inner.value()) }
 func (tx *Transaction) ValueRef() *big.Int { return tx.inner.value() }
 
 // Nonce returns the sender account nonce of the transaction.
@@ -328,14 +325,16 @@ func (tx *Transaction) GasFeeCapCmp(other *Transaction) int {
 	return tx.inner.gasFeeCap().Cmp(other.inner.gasFeeCap())
 }
 
-// GasFeeCapIntCmp compares the fee cap of the transaction against the given fee cap.
 func (tx *Transaction) GasFeeCapIntCmp(other *big.Int) int {
-	return tx.inner.gasFeeCap().Cmp(other)
+	return tx.inner.gasTipCap().Cmp(other)
 }
 
 func (tx *Transaction) GasFeeCapUIntCmp(other *uint256.Int) int {
-	b, _ := uint256.FromBig(tx.inner.gasFeeCap())
-	return b.Cmp(other)
+	return tx.inner.gasFeeCapU256().Cmp(other)
+}
+
+func (tx *Transaction) GasFeeCapUIntLt(other *uint256.Int) bool {
+	return tx.inner.gasFeeCapU256().Lt(other)
 }
 
 // GasTipCapCmp compares the gasTipCap of two transactions.
@@ -349,8 +348,11 @@ func (tx *Transaction) GasTipCapIntCmp(other *big.Int) int {
 }
 
 func (tx *Transaction) GasTipCapUIntCmp(other *uint256.Int) int {
-	b, _ := uint256.FromBig(tx.inner.gasTipCap())
-	return b.Cmp(other)
+	return tx.inner.gasTipCapU256().Cmp(other)
+}
+
+func (tx *Transaction) GasTipCapUIntLt(other *uint256.Int) bool {
+	return tx.inner.gasTipCapU256().Lt(other)
 }
 
 // EffectiveGasTip returns the effective miner gasTipCap for the given base fee.

From ee7f287d7befa6ad246e26a8798592059fd1c8b1 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Fri, 21 Oct 2022 22:44:00 +0400
Subject: [PATCH 33/96] no locks between pending and reorg

---
 core/tx_list.go      |  37 +++++++++++
 core/tx_pool.go      | 148 ++++++++++++++++++++++++++++++++++++-------
 core/tx_pool_test.go |  79 +++++++++++++++++++++++
 3 files changed, 242 insertions(+), 22 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 8b72764e3b..7557a95600 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -58,6 +58,7 @@ type txSortedMap struct {
 	items map[uint64]*types.Transaction // Hash map storing the transaction data
 	index *nonceHeap                    // Heap of nonces of all the stored transactions (non-strict mode)
 	cache types.Transactions            // Cache of the transactions already sorted
+	m     sync.RWMutex
 }
 
 // newTxSortedMap creates a new nonce-sorted transaction map.
@@ -70,16 +71,23 @@ func newTxSortedMap() *txSortedMap {
 
 // Get retrieves the current transactions associated with the given nonce.
 func (m *txSortedMap) Get(nonce uint64) *types.Transaction {
+	m.m.RLock()
+	defer m.m.RUnlock()
+
 	return m.items[nonce]
 }
 
 // Put inserts a new transaction into the map, also updating the map's nonce
 // index. If a transaction already exists with the same nonce, it's overwritten.
 func (m *txSortedMap) Put(tx *types.Transaction) {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	nonce := tx.Nonce()
 	if m.items[nonce] == nil {
 		heap.Push(m.index, nonce)
 	}
+
 	m.items[nonce], m.cache = tx, nil
 }
 
@@ -87,6 +95,9 @@ func (m *txSortedMap) Put(tx *types.Transaction) {
 // provided threshold. Every removed transaction is returned for any post-removal
 // maintenance.
 func (m *txSortedMap) Forward(threshold uint64) types.Transactions {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	var removed types.Transactions
 
 	// Pop off heap items until the threshold is reached
@@ -95,10 +106,12 @@ func (m *txSortedMap) Forward(threshold uint64) types.Transactions {
 		removed = append(removed, m.items[nonce])
 		delete(m.items, nonce)
 	}
+
 	// If we had a cached order, shift the front
 	if m.cache != nil {
 		m.cache = m.cache[len(removed):]
 	}
+
 	return removed
 }
 
@@ -108,6 +121,9 @@ func (m *txSortedMap) Forward(threshold uint64) types.Transactions {
 // If you want to do several consecutive filterings, it's therefore better to first
 // do a .filter(func1) followed by .Filter(func2) or reheap()
 func (m *txSortedMap) Filter(filter func(*types.Transaction) bool) types.Transactions {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	removed := m.filter(filter)
 	// If transactions were removed, the heap and cache are ruined
 	if len(removed) > 0 {
@@ -146,6 +162,9 @@ func (m *txSortedMap) filter(filter func(*types.Transaction) bool) types.Transac
 // Cap places a hard limit on the number of items, returning all transactions
 // exceeding that limit.
 func (m *txSortedMap) Cap(threshold int) types.Transactions {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	// Short circuit if the number of items is under the limit
 	if len(m.items) <= threshold {
 		return nil
@@ -158,6 +177,7 @@ func (m *txSortedMap) Cap(threshold int) types.Transactions {
 		drops = append(drops, m.items[(*m.index)[size-1]])
 		delete(m.items, (*m.index)[size-1])
 	}
+
 	*m.index = (*m.index)[:threshold]
 	heap.Init(m.index)
 
@@ -165,12 +185,16 @@ func (m *txSortedMap) Cap(threshold int) types.Transactions {
 	if m.cache != nil {
 		m.cache = m.cache[:len(m.cache)-len(drops)]
 	}
+
 	return drops
 }
 
 // Remove deletes a transaction from the maintained map, returning whether the
 // transaction was found.
 func (m *txSortedMap) Remove(nonce uint64) bool {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	// Short circuit if no transaction is present
 	_, ok := m.items[nonce]
 	if !ok {
@@ -197,6 +221,9 @@ func (m *txSortedMap) Remove(nonce uint64) bool {
 // prevent getting into and invalid state. This is not something that should ever
 // happen but better to be self correcting than failing!
 func (m *txSortedMap) Ready(start uint64) types.Transactions {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	// Short circuit if no transactions are available
 	if m.index.Len() == 0 || (*m.index)[0] > start {
 		return nil
@@ -215,6 +242,9 @@ func (m *txSortedMap) Ready(start uint64) types.Transactions {
 
 // Len returns the length of the transaction map.
 func (m *txSortedMap) Len() int {
+	m.m.RLock()
+	defer m.m.RUnlock()
+
 	return len(m.items)
 }
 
@@ -234,16 +264,23 @@ func (m *txSortedMap) flatten() types.Transactions {
 // sorted internal representation. The result of the sorting is cached in case
 // it's requested again before any modifications are made to the contents.
 func (m *txSortedMap) Flatten() types.Transactions {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	// Copy the cache to prevent accidental modifications
 	cache := m.flatten()
 	txs := make(types.Transactions, len(cache))
 	copy(txs, cache)
+
 	return txs
 }
 
 // LastElement returns the last element of a flattened list, thus, the
 // transaction with the highest nonce
 func (m *txSortedMap) LastElement() *types.Transaction {
+	m.m.Lock()
+	defer m.m.Unlock()
+
 	cache := m.flatten()
 	return cache[len(cache)-1]
 }
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 0fb8871d9e..3d04337ae8 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -255,6 +255,7 @@ type TxPool struct {
 
 	pending      map[common.Address]*txList // All currently processable transactions
 	pendingCount int
+	pendingMu    sync.RWMutex
 	queue        map[common.Address]*txList   // Queued but non-processable transactions
 	beats        map[common.Address]time.Time // Last heartbeat from each known account
 	all          *txLookup                    // All transactions to allow lookups
@@ -509,13 +510,18 @@ func (pool *TxPool) Stats() (int, int) {
 // number of queued (non-executable) transactions.
 func (pool *TxPool) stats() (int, int) {
 	pending := 0
+
+	pool.pendingMu.RLock()
 	for _, list := range pool.pending {
 		pending += list.Len()
 	}
+	pool.pendingMu.RUnlock()
+
 	queued := 0
 	for _, list := range pool.queue {
 		queued += list.Len()
 	}
+
 	return pending, queued
 }
 
@@ -526,9 +532,13 @@ func (pool *TxPool) Content() (map[common.Address]types.Transactions, map[common
 	defer pool.mu.Unlock()
 
 	pending := make(map[common.Address]types.Transactions)
+
+	pool.pendingMu.RLock()
 	for addr, list := range pool.pending {
 		pending[addr] = list.Flatten()
 	}
+	pool.pendingMu.RUnlock()
+
 	queued := make(map[common.Address]types.Transactions)
 	for addr, list := range pool.queue {
 		queued[addr] = list.Flatten()
@@ -543,9 +553,13 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 	defer pool.mu.RUnlock()
 
 	var pending types.Transactions
+
+	pool.pendingMu.RLock()
 	if list, ok := pool.pending[addr]; ok {
 		pending = list.Flatten()
 	}
+	pool.pendingMu.RUnlock()
+
 	var queued types.Transactions
 	if list, ok := pool.queue[addr]; ok {
 		queued = list.Flatten()
@@ -561,10 +575,11 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 // transactions and only return those whose **effective** tip is large enough in
 // the next pending execution environment.
 func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transactions {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
-
 	pending := make(map[common.Address]types.Transactions)
+
+	pool.pendingMu.RLock()
+	defer pool.pendingMu.RUnlock()
+
 	for addr, list := range pool.pending {
 		txs := list.Flatten()
 
@@ -580,7 +595,9 @@ func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transacti
 		if len(txs) > 0 {
 			pending[addr] = txs
 		}
+
 	}
+
 	return pending
 }
 
@@ -597,14 +614,19 @@ func (pool *TxPool) Locals() []common.Address {
 // freely modified by calling code.
 func (pool *TxPool) local() map[common.Address]types.Transactions {
 	txs := make(map[common.Address]types.Transactions)
+
 	for addr := range pool.locals.accounts {
+		pool.pendingMu.RLock()
 		if pending := pool.pending[addr]; pending != nil {
 			txs[addr] = append(txs[addr], pending.Flatten()...)
 		}
+		pool.pendingMu.RUnlock()
+
 		if queued := pool.queue[addr]; queued != nil {
 			txs[addr] = append(txs[addr], queued.Flatten()...)
 		}
 	}
+
 	return txs
 }
 
@@ -754,10 +776,15 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 	}
 	// Try to replace an existing transaction in the pending pool
 	from, _ := types.Sender(pool.signer, tx) // already validated
-	if list := pool.pending[from]; list != nil && list.Overlaps(tx) {
+
+	pool.pendingMu.RLock()
+	list := pool.pending[from]
+
+	if list != nil && list.Overlaps(tx) {
 		// Nonce already pending, check if required price bump is met
 		inserted, old := list.Add(tx, pool.config.PriceBump)
 		pool.pendingCount++
+		pool.pendingMu.RUnlock()
 
 		if !inserted {
 			pendingDiscardMeter.Mark(1)
@@ -769,6 +796,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 			pool.priced.Removed(1)
 			pendingReplaceMeter.Mark(1)
 		}
+
 		pool.all.Add(tx, isLocal)
 		pool.priced.Put(tx, isLocal)
 		pool.journalTx(from, tx)
@@ -777,8 +805,12 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 
 		// Successful promotion, bump the heartbeat
 		pool.beats[from] = time.Now()
+
 		return old != nil, nil
 	}
+
+	pool.pendingMu.RUnlock()
+
 	// New transaction isn't replacing a pending one, push into queue
 	replaced, err = pool.enqueueTx(hash, tx, isLocal, true)
 	if err != nil {
@@ -868,6 +900,7 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T
 	}()
 
 	// Try to insert the transaction into the pending queue
+	pool.pendingMu.Lock()
 	if pool.pending[addr] == nil {
 		pool.pending[addr] = newTxList(true)
 	}
@@ -875,13 +908,17 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T
 
 	inserted, old := list.Add(tx, pool.config.PriceBump)
 	pool.pendingCount++
+	pool.pendingMu.Unlock()
+
 	if !inserted {
 		// An older transaction was better, discard this
 		pool.all.Remove(hash)
 		pool.priced.Removed(1)
 		pendingDiscardMeter.Mark(1)
+
 		return false
 	}
+
 	// Otherwise discard any previous transaction and mark this
 	if old != nil {
 		pool.all.Remove(old.Hash())
@@ -891,11 +928,13 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T
 		// Nothing was replaced, bump the pending counter
 		pendingGauge.Inc(1)
 	}
+
 	// Set the potentially new pending nonce and notify any subsystems of the new tx
 	pool.pendingNonces.set(addr, tx.Nonce()+1)
 
 	// Successful promotion, bump the heartbeat
 	pool.beats[addr] = time.Now()
+
 	return true
 }
 
@@ -1024,22 +1063,31 @@ func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error,
 // identified by their hashes.
 func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 	status := make([]TxStatus, len(hashes))
+
+	var txList *txList
+
 	for i, hash := range hashes {
 		tx := pool.Get(hash)
 		if tx == nil {
 			continue
 		}
+
 		from, _ := types.Sender(pool.signer, tx) // already validated
+
 		pool.mu.RLock()
-		if txList := pool.pending[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
+		pool.pendingMu.RLock()
+		if txList = pool.pending[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
 			status[i] = TxStatusPending
 		} else if txList := pool.queue[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
 			status[i] = TxStatusQueued
 		}
+
 		// implicit else: the tx may have been included into a block between
 		// checking pool.Get and obtaining the lock. In that case, TxStatusUnknown is correct
+		pool.pendingMu.RUnlock()
 		pool.mu.RUnlock()
 	}
+
 	return status
 }
 
@@ -1072,32 +1120,47 @@ func (pool *TxPool) removeTx(hash common.Hash, outofbound bool) {
 	if pool.locals.contains(addr) {
 		localGauge.Dec(1)
 	}
+
 	// Remove the transaction from the pending lists and reset the account nonce
+	pool.pendingMu.Lock()
+
 	if pending := pool.pending[addr]; pending != nil {
 		if removed, invalids := pending.Remove(tx); removed {
 			pool.pendingCount--
+
 			// If no more pending transactions are left, remove the list
 			if pending.Empty() {
 				delete(pool.pending, addr)
 			}
+			pool.pendingMu.Unlock()
+
 			// Postpone any invalidated transactions
 			for _, tx := range invalids {
 				// Internal shuffle shouldn't touch the lookup set.
 				pool.enqueueTx(tx.Hash(), tx, false, false)
 			}
+
 			// Update the account nonce if needed
 			pool.pendingNonces.setIfLower(addr, tx.Nonce())
+
 			// Reduce the pending counter
 			pendingGauge.Dec(int64(1 + len(invalids)))
+
 			return
 		}
+
+		pool.pendingMu.TryLock()
 	}
+
+	pool.pendingMu.Unlock()
+
 	// Transaction is in the future queue
 	if future := pool.queue[addr]; future != nil {
 		if removed, _ := future.Remove(tx); removed {
 			// Reduce the queued counter
 			queuedGauge.Dec(1)
 		}
+
 		if future.Empty() {
 			delete(pool.queue, addr)
 			delete(pool.beats, addr)
@@ -1247,6 +1310,7 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 	// If a new block appeared, validate the pool of pending transactions. This will
 	// remove any transaction that has been included in the block or was invalidated
 	// because of another transaction (e.g. higher gas price).
+
 	if reset != nil {
 		pool.demoteUnexecutables()
 		if reset.newHead != nil {
@@ -1261,12 +1325,18 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 		}
 		// Update all accounts to the latest known pending nonce
 		nonces := make(map[common.Address]uint64, len(pool.pending))
+
+		pool.pendingMu.RLock()
 		for addr, list := range pool.pending {
 			highestPending := list.LastElement()
 			nonces[addr] = highestPending.Nonce() + 1
 		}
+
+		pool.pendingMu.RUnlock()
+
 		pool.pendingNonces.setAll(nonces)
 	}
+
 	// Ensure pool.queue and pool.pending sizes stay within the configured limits.
 	pool.truncatePending()
 	pool.truncateQueue()
@@ -1283,6 +1353,7 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 		}
 		events[addr].Put(tx)
 	}
+
 	if len(events) > 0 {
 		var txs []*types.Transaction
 		for _, set := range events {
@@ -1508,6 +1579,7 @@ func (pool *TxPool) truncatePending() {
 
 	var ok bool
 
+	pool.pendingMu.RLock()
 	for addr, list := range pool.pending {
 		// Only evict transactions from high rollers
 		listLen = len(list.txs.items)
@@ -1521,6 +1593,7 @@ func (pool *TxPool) truncatePending() {
 			spammers = append(spammers, pair{addr, int64(listLen)})
 		}
 	}
+	pool.pendingMu.RUnlock()
 
 	// Gradually drop transactions from offenders
 	offenders := make([]common.Address, 0, len(spammers))
@@ -1531,6 +1604,9 @@ func (pool *TxPool) truncatePending() {
 	var (
 		offender common.Address
 		caps     types.Transactions
+		capsLen  int
+		list     *txList
+		hash     common.Hash
 	)
 
 	// todo: metrics: spammers, offenders, total loops
@@ -1544,19 +1620,19 @@ func (pool *TxPool) truncatePending() {
 		// Equalize balances until all the same or below threshold
 		if len(offenders) > 1 {
 			// Calculate the equalization threshold for all current offenders
+			pool.pendingMu.RLock()
 			threshold = len(pool.pending[offender].txs.items)
 
-			var (
-				list *txList
-				hash common.Hash
-			)
-
 			// Iteratively reduce all offenders until below limit or threshold reached
 			for pending > pool.config.GlobalSlots && pool.pending[offenders[len(offenders)-2]].Len() > threshold {
 				for i := 0; i < len(offenders)-1; i++ {
 					list = pool.pending[offenders[i]]
 
 					caps = list.Cap(len(list.txs.items) - 1)
+					capsLen = len(caps)
+
+					pool.pendingMu.RUnlock()
+
 					for _, tx := range caps {
 						// Drop the transaction from the global pools too
 						hash = tx.Hash()
@@ -1567,31 +1643,37 @@ func (pool *TxPool) truncatePending() {
 						log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)
 					}
 
-					pool.priced.Removed(len(caps))
+					pool.priced.Removed(capsLen)
 
-					pendingGauge.Dec(int64(len(caps)))
+					pendingGauge.Dec(int64(capsLen))
 					if pool.locals.contains(offenders[i]) {
-						localGauge.Dec(int64(len(caps)))
+						localGauge.Dec(int64(capsLen))
 					}
 
 					pending--
+
+					pool.pendingMu.RLock()
 				}
 			}
+
+			pool.pendingMu.RUnlock()
 		}
 	}
 
 	// If still above threshold, reduce to limit or min allowance
 	if pending > pool.config.GlobalSlots && len(offenders) > 0 {
-		var (
-			list *txList
-			hash common.Hash
-		)
+
+		pool.pendingMu.RLock()
 
 		for pending > pool.config.GlobalSlots && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > pool.config.AccountSlots {
 			for _, addr := range offenders {
 				list = pool.pending[addr]
 
 				caps = list.Cap(len(list.txs.items) - 1)
+				capsLen = len(caps)
+
+				pool.pendingMu.RUnlock()
+
 				for _, tx := range caps {
 					// Drop the transaction from the global pools too
 					hash = tx.Hash()
@@ -1601,18 +1683,23 @@ func (pool *TxPool) truncatePending() {
 					pool.pendingNonces.setIfLower(addr, tx.Nonce())
 					log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)
 				}
-				pool.priced.Removed(len(caps))
+				pool.priced.Removed(capsLen)
 
-				pendingGauge.Dec(int64(len(caps)))
+				pendingGauge.Dec(int64(capsLen))
 
 				if _, ok = pool.locals.accounts[addr]; ok {
-					localGauge.Dec(int64(len(caps)))
+					localGauge.Dec(int64(capsLen))
 				}
 
 				pending--
+
+				pool.pendingMu.RLock()
 			}
 		}
+
+		pool.pendingMu.RUnlock()
 	}
+
 	pendingRateLimitMeter.Mark(int64(pendingBeforeCap - pending))
 }
 
@@ -1650,20 +1737,33 @@ func (pool *TxPool) truncateQueue() {
 
 		addresses = addresses[:len(addresses)-1]
 
+		var listFlatten types.Transactions
+
 		// Drop all transactions if they are less than the overflow
 		if size = uint64(list.Len()); size <= drop {
-			for _, tx = range list.Flatten() {
+			listFlatten = list.Flatten()
+
+			for _, tx = range listFlatten {
 				pool.removeTx(tx.Hash(), true)
 			}
+
 			drop -= size
 			queuedRateLimitMeter.Mark(int64(size))
+
 			continue
 		}
+
 		// Otherwise drop only last few transactions
-		txs = list.Flatten()
+		if listFlatten == nil {
+			listFlatten = list.Flatten()
+		}
+
+		txs = listFlatten
 		for i := len(txs) - 1; i >= 0 && drop > 0; i-- {
 			pool.removeTx(txs[i].Hash(), true)
+
 			drop--
+
 			queuedRateLimitMeter.Mark(1)
 		}
 	}
@@ -1692,6 +1792,9 @@ func (pool *TxPool) demoteUnexecutables() {
 	)
 
 	// Iterate over all accounts and demote any non-executable transactions
+	pool.pendingMu.Lock()
+	defer pool.pendingMu.Unlock()
+
 	for addr, list := range pool.pending {
 		nonce := pool.currentState.GetNonce(addr)
 
@@ -1704,6 +1807,7 @@ func (pool *TxPool) demoteUnexecutables() {
 			pool.all.Remove(hash)
 			log.Trace("Removed old pending transaction", "hash", hash)
 		}
+
 		// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
 		balance.SetFromBig(pool.currentState.GetBalance(addr))
 		drops, invalids = list.Filter(balance, pool.currentMaxGas)
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 5b421b9fe1..e86007f210 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -154,12 +154,17 @@ func validateTxPoolInternals(pool *TxPool) error {
 	if total := pool.all.Count(); total != pending+queued {
 		return fmt.Errorf("total transaction count %d != %d pending + %d queued", total, pending, queued)
 	}
+
 	pool.priced.Reheap()
 	priced, remote := pool.priced.urgent.Len()+pool.priced.floating.Len(), pool.all.RemoteCount()
 	if priced != remote {
 		return fmt.Errorf("total priced transaction count %d != %d", priced, remote)
 	}
+
 	// Ensure the next nonce to assign is the correct one
+	pool.pendingMu.RLock()
+	defer pool.pendingMu.RUnlock()
+
 	for addr, txs := range pool.pending {
 		// Find the last transaction
 		var last uint64
@@ -168,10 +173,12 @@ func validateTxPoolInternals(pool *TxPool) error {
 				last = nonce
 			}
 		}
+
 		if nonce := pool.pendingNonces.get(addr); nonce != last+1 {
 			return fmt.Errorf("pending nonce mismatch: have %v, want %v", nonce, last+1)
 		}
 	}
+
 	return nil
 }
 
@@ -349,9 +356,12 @@ func TestTransactionQueue(t *testing.T) {
 
 	pool.enqueueTx(tx.Hash(), tx, false, true)
 	<-pool.requestPromoteExecutables(newAccountSet(pool.signer, from))
+
+	pool.pendingMu.RLock()
 	if len(pool.pending) != 1 {
 		t.Error("expected valid txs to be 1 is", len(pool.pending))
 	}
+	pool.pendingMu.RUnlock()
 
 	tx = transaction(1, 100, key)
 	from, _ = deriveSender(tx)
@@ -359,9 +369,13 @@ func TestTransactionQueue(t *testing.T) {
 	pool.enqueueTx(tx.Hash(), tx, false, true)
 
 	<-pool.requestPromoteExecutables(newAccountSet(pool.signer, from))
+
+	pool.pendingMu.RLock()
 	if _, ok := pool.pending[from].txs.items[tx.Nonce()]; ok {
 		t.Error("expected transaction to be in tx pool")
 	}
+	pool.pendingMu.RUnlock()
+
 	if len(pool.queue) > 0 {
 		t.Error("expected transaction queue to be empty. is", len(pool.queue))
 	}
@@ -385,9 +399,13 @@ func TestTransactionQueue2(t *testing.T) {
 	pool.enqueueTx(tx3.Hash(), tx3, false, true)
 
 	pool.promoteExecutables([]common.Address{from})
+
+	pool.pendingMu.RLock()
 	if len(pool.pending) != 1 {
 		t.Error("expected pending length to be 1, got", len(pool.pending))
 	}
+	pool.pendingMu.RUnlock()
+
 	if pool.queue[from].Len() != 2 {
 		t.Error("expected len(queue) == 2, got", pool.queue[from].Len())
 	}
@@ -497,23 +515,32 @@ func TestTransactionDoubleNonce(t *testing.T) {
 	if replace, err := pool.add(tx2, false); err != nil || !replace {
 		t.Errorf("second transaction insert failed (%v) or not reported replacement (%v)", err, replace)
 	}
+
 	<-pool.requestPromoteExecutables(newAccountSet(signer, addr))
+
+	pool.pendingMu.RLock()
 	if pool.pending[addr].Len() != 1 {
 		t.Error("expected 1 pending transactions, got", pool.pending[addr].Len())
 	}
 	if tx := pool.pending[addr].txs.items[0]; tx.Hash() != tx2.Hash() {
 		t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx2.Hash())
 	}
+	pool.pendingMu.RUnlock()
 
 	// Add the third transaction and ensure it's not saved (smaller price)
 	pool.add(tx3, false)
+
 	<-pool.requestPromoteExecutables(newAccountSet(signer, addr))
+
+	pool.pendingMu.RLock()
 	if pool.pending[addr].Len() != 1 {
 		t.Error("expected 1 pending transactions, got", pool.pending[addr].Len())
 	}
 	if tx := pool.pending[addr].txs.items[0]; tx.Hash() != tx2.Hash() {
 		t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx2.Hash())
 	}
+	pool.pendingMu.RUnlock()
+
 	// Ensure the total transaction count is correct
 	if pool.all.Count() != 1 {
 		t.Error("expected 1 total transactions, got", pool.all.Count())
@@ -532,9 +559,13 @@ func TestTransactionMissingNonce(t *testing.T) {
 	if _, err := pool.add(tx, false); err != nil {
 		t.Error("didn't expect error", err)
 	}
+
+	pool.pendingMu.RLock()
 	if len(pool.pending) != 0 {
 		t.Error("expected 0 pending transactions, got", len(pool.pending))
 	}
+	pool.pendingMu.RUnlock()
+
 	if pool.queue[addr].Len() != 1 {
 		t.Error("expected 1 queued transaction, got", pool.queue[addr].Len())
 	}
@@ -605,19 +636,27 @@ func TestTransactionDropping(t *testing.T) {
 	pool.enqueueTx(tx12.Hash(), tx12, false, true)
 
 	// Check that pre and post validations leave the pool as is
+	pool.pendingMu.RLock()
 	if pool.pending[account].Len() != 3 {
 		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), 3)
 	}
+	pool.pendingMu.RUnlock()
+
 	if pool.queue[account].Len() != 3 {
 		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 3)
 	}
 	if pool.all.Count() != 6 {
 		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 6)
 	}
+
 	<-pool.requestReset(nil, nil)
+
+	pool.pendingMu.RLock()
 	if pool.pending[account].Len() != 3 {
 		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), 3)
 	}
+	pool.pendingMu.RUnlock()
+
 	if pool.queue[account].Len() != 3 {
 		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 3)
 	}
@@ -628,6 +667,7 @@ func TestTransactionDropping(t *testing.T) {
 	testAddBalance(pool, account, big.NewInt(-650))
 	<-pool.requestReset(nil, nil)
 
+	pool.pendingMu.RLock()
 	if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok {
 		t.Errorf("funded pending transaction missing: %v", tx0)
 	}
@@ -637,6 +677,8 @@ func TestTransactionDropping(t *testing.T) {
 	if _, ok := pool.pending[account].txs.items[tx2.Nonce()]; ok {
 		t.Errorf("out-of-fund pending transaction present: %v", tx1)
 	}
+	pool.pendingMu.RUnlock()
+
 	if _, ok := pool.queue[account].txs.items[tx10.Nonce()]; !ok {
 		t.Errorf("funded queued transaction missing: %v", tx10)
 	}
@@ -653,12 +695,15 @@ func TestTransactionDropping(t *testing.T) {
 	atomic.StoreUint64(&pool.chain.(*testBlockChain).gasLimit, 100)
 	<-pool.requestReset(nil, nil)
 
+	pool.pendingMu.RLock()
 	if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok {
 		t.Errorf("funded pending transaction missing: %v", tx0)
 	}
 	if _, ok := pool.pending[account].txs.items[tx1.Nonce()]; ok {
 		t.Errorf("over-gased pending transaction present: %v", tx1)
 	}
+	pool.pendingMu.RUnlock()
+
 	if _, ok := pool.queue[account].txs.items[tx10.Nonce()]; !ok {
 		t.Errorf("funded queued transaction missing: %v", tx10)
 	}
@@ -713,19 +758,27 @@ func TestTransactionPostponing(t *testing.T) {
 		}
 	}
 	// Check that pre and post validations leave the pool as is
+	pool.pendingMu.RLock()
 	if pending := pool.pending[accs[0]].Len() + pool.pending[accs[1]].Len(); pending != len(txs) {
 		t.Errorf("pending transaction mismatch: have %d, want %d", pending, len(txs))
 	}
+	pool.pendingMu.RUnlock()
+
 	if len(pool.queue) != 0 {
 		t.Errorf("queued accounts mismatch: have %d, want %d", len(pool.queue), 0)
 	}
 	if pool.all.Count() != len(txs) {
 		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), len(txs))
 	}
+
 	<-pool.requestReset(nil, nil)
+
+	pool.pendingMu.RLock()
 	if pending := pool.pending[accs[0]].Len() + pool.pending[accs[1]].Len(); pending != len(txs) {
 		t.Errorf("pending transaction mismatch: have %d, want %d", pending, len(txs))
 	}
+	pool.pendingMu.RUnlock()
+
 	if len(pool.queue) != 0 {
 		t.Errorf("queued accounts mismatch: have %d, want %d", len(pool.queue), 0)
 	}
@@ -740,12 +793,17 @@ func TestTransactionPostponing(t *testing.T) {
 
 	// The first account's first transaction remains valid, check that subsequent
 	// ones are either filtered out, or queued up for later.
+	pool.pendingMu.RLock()
 	if _, ok := pool.pending[accs[0]].txs.items[txs[0].Nonce()]; !ok {
 		t.Errorf("tx %d: valid and funded transaction missing from pending pool: %v", 0, txs[0])
 	}
+	pool.pendingMu.RUnlock()
+
 	if _, ok := pool.queue[accs[0]].txs.items[txs[0].Nonce()]; ok {
 		t.Errorf("tx %d: valid and funded transaction present in future queue: %v", 0, txs[0])
 	}
+
+	pool.pendingMu.RLock()
 	for i, tx := range txs[1:100] {
 		if i%2 == 1 {
 			if _, ok := pool.pending[accs[0]].txs.items[tx.Nonce()]; ok {
@@ -763,11 +821,16 @@ func TestTransactionPostponing(t *testing.T) {
 			}
 		}
 	}
+	pool.pendingMu.RUnlock()
+
 	// The second account's first transaction got invalid, check that all transactions
 	// are either filtered out, or queued up for later.
+	pool.pendingMu.RLock()
 	if pool.pending[accs[1]] != nil {
 		t.Errorf("invalidated account still has pending transactions")
 	}
+	pool.pendingMu.RUnlock()
+
 	for i, tx := range txs[100:] {
 		if i%2 == 1 {
 			if _, ok := pool.queue[accs[1]].txs.items[tx.Nonce()]; !ok {
@@ -856,9 +919,13 @@ func TestTransactionQueueAccountLimiting(t *testing.T) {
 		if err := pool.addRemoteSync(transaction(i, 100000, key)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
+
+		pool.pendingMu.RLock()
 		if len(pool.pending) != 0 {
 			t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, len(pool.pending), 0)
 		}
+		pool.pendingMu.RUnlock()
+
 		if i <= testTxPoolConfig.AccountQueue {
 			if pool.queue[account].Len() != int(i) {
 				t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, pool.queue[account].Len(), i)
@@ -1114,6 +1181,7 @@ func testTransactionQueueTimeLimiting(t *testing.T, nolocals bool) {
 			t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 1)
 		}
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
@@ -1142,9 +1210,13 @@ func TestTransactionPendingLimiting(t *testing.T) {
 		if err := pool.addRemoteSync(transaction(i, 100000, key)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
+
+		pool.pendingMu.RLock()
 		if pool.pending[account].Len() != int(i)+1 {
 			t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, pool.pending[account].Len(), i+1)
 		}
+		pool.pendingMu.RUnlock()
+
 		if len(pool.queue) != 0 {
 			t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, pool.queue[account].Len(), 0)
 		}
@@ -1197,9 +1269,13 @@ func TestTransactionPendingGlobalLimiting(t *testing.T) {
 	pool.AddRemotesSync(txs)
 
 	pending := 0
+
+	pool.pendingMu.RLock()
 	for _, list := range pool.pending {
 		pending += list.Len()
 	}
+	pool.pendingMu.RUnlock()
+
 	if pending > int(config.GlobalSlots) {
 		t.Fatalf("total pending transactions overflow allowance: %d > %d", pending, config.GlobalSlots)
 	}
@@ -1332,11 +1408,14 @@ func TestTransactionPendingMinimumAllowance(t *testing.T) {
 	// Import the batch and verify that limits have been enforced
 	pool.AddRemotesSync(txs)
 
+	pool.pendingMu.RLock()
 	for addr, list := range pool.pending {
 		if list.Len() != int(config.AccountSlots) {
 			t.Errorf("addr %x: total pending transactions mismatch: have %d, want %d", addr, list.Len(), config.AccountSlots)
 		}
 	}
+	pool.pendingMu.RUnlock()
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}

From 0663649239dfbeae2c0bb9c355f61391f3897f53 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Fri, 21 Oct 2022 23:16:39 +0400
Subject: [PATCH 34/96] no locks

---
 core/tx_pool.go      |   9 +++-
 core/tx_pool_test.go | 103 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 109 insertions(+), 3 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 3d04337ae8..9b33282afe 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -1683,6 +1683,7 @@ func (pool *TxPool) truncatePending() {
 					pool.pendingNonces.setIfLower(addr, tx.Nonce())
 					log.Trace("Removed fairness-exceeding pending transaction", "hash", hash)
 				}
+
 				pool.priced.Removed(capsLen)
 
 				pendingGauge.Dec(int64(capsLen))
@@ -1737,11 +1738,15 @@ func (pool *TxPool) truncateQueue() {
 
 		addresses = addresses[:len(addresses)-1]
 
-		var listFlatten types.Transactions
+		var (
+			listFlatten types.Transactions
+			isSet       bool
+		)
 
 		// Drop all transactions if they are less than the overflow
 		if size = uint64(list.Len()); size <= drop {
 			listFlatten = list.Flatten()
+			isSet = true
 
 			for _, tx = range listFlatten {
 				pool.removeTx(tx.Hash(), true)
@@ -1754,7 +1759,7 @@ func (pool *TxPool) truncateQueue() {
 		}
 
 		// Otherwise drop only last few transactions
-		if listFlatten == nil {
+		if !isSet {
 			listFlatten = list.Flatten()
 		}
 
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index e86007f210..94c2c4310d 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -21,6 +21,7 @@ import (
 	"crypto/ecdsa"
 	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"math/big"
 	"math/rand"
@@ -2653,7 +2654,7 @@ func BenchmarkPoolMultiAccountBatchInsert(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
 	pool, _ := setupTxPool()
 	defer pool.Stop()
-	b.ReportAllocs()
+
 	batches := make(types.Transactions, b.N)
 	for i := 0; i < b.N; i++ {
 		key, _ := crypto.GenerateKey()
@@ -2662,13 +2663,113 @@ func BenchmarkPoolMultiAccountBatchInsert(b *testing.B) {
 		tx := transaction(uint64(0), 100000, key)
 		batches[i] = tx
 	}
+
 	// Benchmark importing the transactions into the queue
+	b.ReportAllocs()
 	b.ResetTimer()
+
 	for _, tx := range batches {
 		pool.AddRemotesSync([]*types.Transaction{tx})
 	}
 }
 
+func BenchmarkPoolMultiAccountBatchInsertRace(b *testing.B) {
+	// Generate a batch of transactions to enqueue into the pool
+	pool, _ := setupTxPool()
+	defer pool.Stop()
+
+	batches := make(types.Transactions, b.N)
+
+	for i := 0; i < b.N; i++ {
+		key, _ := crypto.GenerateKey()
+		account := crypto.PubkeyToAddress(key.PublicKey)
+		tx := transaction(uint64(0), 100000, key)
+
+		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
+		batches[i] = tx
+	}
+
+	done := make(chan struct{})
+
+	go func() {
+		t := time.NewTicker(time.Microsecond)
+		defer t.Stop()
+
+		var pending map[common.Address]types.Transactions
+
+	loop:
+		for {
+			select {
+			case <-t.C:
+				pending = pool.Pending(true)
+			case <-done:
+				break loop
+			}
+		}
+
+		fmt.Fprint(io.Discard, pending)
+	}()
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for _, tx := range batches {
+		pool.AddRemotesSync([]*types.Transaction{tx})
+	}
+
+	close(done)
+}
+
+func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
+	t.Parallel()
+
+	// Generate a batch of transactions to enqueue into the pool
+	pool, _ := setupTxPool()
+	defer pool.Stop()
+
+	const n = 5000
+
+	batches := make(types.Transactions, n)
+
+	for i := 0; i < n; i++ {
+		key, _ := crypto.GenerateKey()
+		account := crypto.PubkeyToAddress(key.PublicKey)
+		tx := transaction(uint64(0), 100000, key)
+
+		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
+		batches[i] = tx
+	}
+
+	done := make(chan struct{})
+
+	go func() {
+		t := time.NewTicker(time.Microsecond)
+		defer t.Stop()
+
+		var pending map[common.Address]types.Transactions
+
+	loop:
+		for {
+			select {
+			case <-t.C:
+				pending = pool.Pending(true)
+			case <-done:
+				break loop
+			}
+		}
+
+		fmt.Fprint(io.Discard, pending)
+	}()
+
+	for _, tx := range batches {
+		pool.AddRemotesSync([]*types.Transaction{tx})
+	}
+
+	close(done)
+}
+
 type acc struct {
 	nonce   uint64
 	key     *ecdsa.PrivateKey

From d842779a0a5ee565db63708b7c137e047ff044b6 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 10:11:06 +0400
Subject: [PATCH 35/96] no locks on locals

---
 core/tx_pool.go      | 39 +++++++++++++++++++++++++++++-----
 core/tx_pool_test.go | 50 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 5 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 9b33282afe..11d465ff1b 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -250,8 +250,9 @@ type TxPool struct {
 	pendingNonces *txNoncer      // Pending state tracking virtual nonces
 	currentMaxGas uint64         // Current gas limit for transaction caps
 
-	locals  *accountSet // Set of local transaction to exempt from eviction rules
-	journal *txJournal  // Journal of local transaction to back up to disk
+	locals   *accountSet // Set of local transaction to exempt from eviction rules
+	localsMu sync.RWMutex
+	journal  *txJournal // Journal of local transaction to back up to disk
 
 	pending      map[common.Address]*txList // All currently processable transactions
 	pendingCount int
@@ -603,9 +604,6 @@ func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transacti
 
 // Locals retrieves the accounts currently considered local by the pool.
 func (pool *TxPool) Locals() []common.Address {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
-
 	return pool.locals.flatten()
 }
 
@@ -615,6 +613,9 @@ func (pool *TxPool) Locals() []common.Address {
 func (pool *TxPool) local() map[common.Address]types.Transactions {
 	txs := make(map[common.Address]types.Transactions)
 
+	pool.locals.m.RLock()
+	defer pool.locals.m.RUnlock()
+
 	for addr := range pool.locals.accounts {
 		pool.pendingMu.RLock()
 		if pending := pool.pending[addr]; pending != nil {
@@ -1583,8 +1584,11 @@ func (pool *TxPool) truncatePending() {
 	for addr, list := range pool.pending {
 		// Only evict transactions from high rollers
 		listLen = len(list.txs.items)
+		pool.locals.m.RLock()
+
 		if uint64(listLen) > pool.config.AccountSlots {
 			if _, ok = pool.locals.accounts[addr]; ok {
+				pool.locals.m.RUnlock()
 				continue
 			}
 
@@ -1592,6 +1596,8 @@ func (pool *TxPool) truncatePending() {
 
 			spammers = append(spammers, pair{addr, int64(listLen)})
 		}
+
+		pool.locals.m.RUnlock()
 	}
 	pool.pendingMu.RUnlock()
 
@@ -1886,6 +1892,7 @@ type accountSet struct {
 	accounts        map[common.Address]struct{}
 	accountsFlatted []common.Address
 	signer          types.Signer
+	m               sync.RWMutex
 }
 
 // newAccountSet creates a new address set with an associated signer for sender
@@ -1903,17 +1910,26 @@ func newAccountSet(signer types.Signer, addrs ...common.Address) *accountSet {
 
 // contains checks if a given address is contained within the set.
 func (as *accountSet) contains(addr common.Address) bool {
+	as.m.RLock()
+	defer as.m.RUnlock()
+
 	_, exist := as.accounts[addr]
 	return exist
 }
 
 func (as *accountSet) empty() bool {
+	as.m.RLock()
+	defer as.m.RUnlock()
+
 	return len(as.accounts) == 0
 }
 
 // containsTx checks if the sender of a given tx is within the set. If the sender
 // cannot be derived, this method returns false.
 func (as *accountSet) containsTx(tx *types.Transaction) bool {
+	as.m.RLock()
+	defer as.m.RUnlock()
+
 	if addr, err := types.Sender(as.signer, tx); err == nil {
 		return as.contains(addr)
 	}
@@ -1922,9 +1938,13 @@ func (as *accountSet) containsTx(tx *types.Transaction) bool {
 
 // add inserts a new address into the set to track.
 func (as *accountSet) add(addr common.Address) {
+	as.m.Lock()
+	defer as.m.Unlock()
+
 	if _, ok := as.accounts[addr]; !ok {
 		as.accountsFlatted = append(as.accountsFlatted, addr)
 	}
+
 	as.accounts[addr] = struct{}{}
 }
 
@@ -1938,6 +1958,9 @@ func (as *accountSet) addTx(tx *types.Transaction) {
 // flatten returns the list of addresses within this set, also caching it for later
 // reuse. The returned slice should not be changed!
 func (as *accountSet) flatten() []common.Address {
+	as.m.RLock()
+	defer as.m.RUnlock()
+
 	return as.accountsFlatted
 }
 
@@ -1945,6 +1968,9 @@ func (as *accountSet) flatten() []common.Address {
 func (as *accountSet) merge(other *accountSet) {
 	var ok bool
 
+	as.m.Lock()
+	defer as.m.Unlock()
+
 	for addr := range other.accounts {
 		if _, ok = as.accounts[addr]; !ok {
 			as.accountsFlatted = append(as.accountsFlatted, addr)
@@ -2106,7 +2132,10 @@ func (t *txLookup) RemoteToLocals(locals *accountSet) int {
 	var migrated int
 	for hash, tx := range t.remotes {
 		if locals.containsTx(tx) {
+			locals.m.Lock()
 			t.locals[hash] = tx
+			locals.m.Unlock()
+
 			delete(t.remotes, hash)
 			migrated += 1
 		}
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 94c2c4310d..f20b466e2f 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2721,6 +2721,56 @@ func BenchmarkPoolMultiAccountBatchInsertRace(b *testing.B) {
 	close(done)
 }
 
+func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
+	// Generate a batch of transactions to enqueue into the pool
+	pool, _ := setupTxPool()
+	defer pool.Stop()
+
+	batches := make(types.Transactions, b.N)
+
+	for i := 0; i < b.N; i++ {
+		key, _ := crypto.GenerateKey()
+		account := crypto.PubkeyToAddress(key.PublicKey)
+		tx := transaction(uint64(0), 100000, key)
+
+		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
+		batches[i] = tx
+	}
+
+	done := make(chan struct{})
+
+	go func() {
+		t := time.NewTicker(time.Microsecond)
+		defer t.Stop()
+
+		var pending map[common.Address]types.Transactions
+
+	loop:
+		for {
+			select {
+			case <-t.C:
+				pending = pool.Pending(true)
+			case <-done:
+				break loop
+			}
+		}
+
+		fmt.Fprint(io.Discard, pending)
+	}()
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for _, tx := range batches {
+		pool.AddRemotes([]*types.Transaction{tx})
+	}
+
+	close(done)
+
+	time.Sleep(10 * time.Second)
+}
+
 func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 	t.Parallel()
 

From 55c749a838e3e046864fa242c298b5be12b195a5 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 10:17:28 +0400
Subject: [PATCH 36/96] more tests

---
 core/tx_pool_test.go | 31 ++++++++++++++++++++++---------
 1 file changed, 22 insertions(+), 9 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index f20b466e2f..03831e7d98 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2781,15 +2781,11 @@ func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 	const n = 5000
 
 	batches := make(types.Transactions, n)
+	batchesSecond := make(types.Transactions, n)
 
 	for i := 0; i < n; i++ {
-		key, _ := crypto.GenerateKey()
-		account := crypto.PubkeyToAddress(key.PublicKey)
-		tx := transaction(uint64(0), 100000, key)
-
-		pool.currentState.AddBalance(account, big.NewInt(1000000))
-
-		batches[i] = tx
+		batches[i] = newTx(pool)
+		batchesSecond[i] = newTx(pool)
 	}
 
 	done := make(chan struct{})
@@ -2798,28 +2794,45 @@ func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 		t := time.NewTicker(time.Microsecond)
 		defer t.Stop()
 
-		var pending map[common.Address]types.Transactions
+		var (
+			pending map[common.Address]types.Transactions
+			locals  []common.Address
+		)
 
 	loop:
 		for {
 			select {
 			case <-t.C:
 				pending = pool.Pending(true)
+				locals = pool.Locals()
 			case <-done:
 				break loop
 			}
 		}
 
-		fmt.Fprint(io.Discard, pending)
+		fmt.Fprint(io.Discard, pending, locals)
 	}()
 
 	for _, tx := range batches {
 		pool.AddRemotesSync([]*types.Transaction{tx})
 	}
 
+	for _, tx := range batchesSecond {
+		pool.AddRemotes([]*types.Transaction{tx})
+	}
+
 	close(done)
 }
 
+func newTx(pool *TxPool) *types.Transaction {
+	key, _ := crypto.GenerateKey()
+	account := crypto.PubkeyToAddress(key.PublicKey)
+	tx := transaction(uint64(0), 100000, key)
+	pool.currentState.AddBalance(account, big.NewInt(1000000))
+
+	return tx
+}
+
 type acc struct {
 	nonce   uint64
 	key     *ecdsa.PrivateKey

From 0576e91e5fdbd296fdf2559cb665f8477378e3a5 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 10:31:18 +0400
Subject: [PATCH 37/96] linters

---
 core/tx_pool.go      | 6 +++---
 core/tx_pool_test.go | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 11d465ff1b..a51f4b8acd 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -250,9 +250,8 @@ type TxPool struct {
 	pendingNonces *txNoncer      // Pending state tracking virtual nonces
 	currentMaxGas uint64         // Current gas limit for transaction caps
 
-	locals   *accountSet // Set of local transaction to exempt from eviction rules
-	localsMu sync.RWMutex
-	journal  *txJournal // Journal of local transaction to back up to disk
+	locals  *accountSet // Set of local transaction to exempt from eviction rules
+	journal *txJournal  // Journal of local transaction to back up to disk
 
 	pending      map[common.Address]*txList // All currently processable transactions
 	pendingCount int
@@ -1584,6 +1583,7 @@ func (pool *TxPool) truncatePending() {
 	for addr, list := range pool.pending {
 		// Only evict transactions from high rollers
 		listLen = len(list.txs.items)
+
 		pool.locals.m.RLock()
 
 		if uint64(listLen) > pool.config.AccountSlots {
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 03831e7d98..28eaf6d466 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2828,6 +2828,7 @@ func newTx(pool *TxPool) *types.Transaction {
 	key, _ := crypto.GenerateKey()
 	account := crypto.PubkeyToAddress(key.PublicKey)
 	tx := transaction(uint64(0), 100000, key)
+
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	return tx

From b5a80fd479b38dab28d2e82a2eceb2bb2f66bb1f Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 10:35:04 +0400
Subject: [PATCH 38/96] less allocs

---
 core/tx_list.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 7557a95600..14132eba92 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -383,9 +383,9 @@ func (l *txList) Filter(costLimit *uint256.Int, gasLimit uint64) (types.Transact
 	l.gascap = gasLimit
 
 	// Filter out all the transactions above the account's funds
-	var cost *uint256.Int
+	cost := uint256.NewInt(0)
 	removed := l.txs.Filter(func(tx *types.Transaction) bool {
-		cost, _ = uint256.FromBig(tx.Cost())
+		cost.SetFromBig(tx.Cost())
 		return tx.Gas() > gasLimit || cost.Gt(costLimit)
 	})
 

From 93ea8a4b6d1f9da061be459dd970dfe7faccaa65 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 10:46:36 +0400
Subject: [PATCH 39/96] comment

---
 core/tx_pool.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index a51f4b8acd..7f7b95d6e1 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -809,6 +809,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 		return old != nil, nil
 	}
 
+	// it is not an unlocking of unlocked because of the return in previous 'if'
 	pool.pendingMu.RUnlock()
 
 	// New transaction isn't replacing a pending one, push into queue

From 8d088a865584589ce9ef0a2bfabad75d9754840a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 20:29:29 +0400
Subject: [PATCH 40/96] optimize errors

---
 core/tx_journal.go        |  17 ++++--
 core/tx_pool.go           |  80 ++++++++++++++++++++-------
 core/tx_pool_test.go      | 110 +++++++++++++++++++-------------------
 core/types/transaction.go |   2 +-
 eth/api_backend.go        |   9 +++-
 5 files changed, 138 insertions(+), 80 deletions(-)

diff --git a/core/tx_journal.go b/core/tx_journal.go
index d282126a08..980bdb9864 100644
--- a/core/tx_journal.go
+++ b/core/tx_journal.go
@@ -61,11 +61,13 @@ func (journal *txJournal) load(add func([]*types.Transaction) []error) error {
 	if _, err := os.Stat(journal.path); os.IsNotExist(err) {
 		return nil
 	}
+
 	// Open the journal for loading any past transactions
 	input, err := os.Open(journal.path)
 	if err != nil {
 		return err
 	}
+
 	defer input.Close()
 
 	// Temporarily discard any journal additions (don't double add on load)
@@ -80,29 +82,35 @@ func (journal *txJournal) load(add func([]*types.Transaction) []error) error {
 	// appropriate progress counters. Then use this method to load all the
 	// journaled transactions in small-ish batches.
 	loadBatch := func(txs types.Transactions) {
+		errs := add(txs)
+
+		dropped = len(errs)
+
 		for _, err := range add(txs) {
-			if err != nil {
-				log.Debug("Failed to add journaled transaction", "err", err)
-				dropped++
-			}
+			log.Debug("Failed to add journaled transaction", "err", err)
 		}
 	}
 	var (
 		failure error
 		batch   types.Transactions
 	)
+
 	for {
 		// Parse the next transaction and terminate on error
 		tx := new(types.Transaction)
+
 		if err = stream.Decode(tx); err != nil {
 			if err != io.EOF {
 				failure = err
 			}
+
 			if batch.Len() > 0 {
 				loadBatch(batch)
 			}
+
 			break
 		}
+
 		// New transaction parsed, queue up for later, import if threshold is reached
 		total++
 
@@ -111,6 +119,7 @@ func (journal *txJournal) load(add func([]*types.Transaction) []error) error {
 			batch = batch[:0]
 		}
 	}
+
 	log.Info("Loaded local transaction journal", "transactions", total, "dropped", dropped)
 
 	return failure
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 7f7b95d6e1..929c98a121 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -18,6 +18,7 @@ package core
 
 import (
 	"errors"
+	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -952,7 +953,11 @@ func (pool *TxPool) AddLocals(txs []*types.Transaction) []error {
 // a convenience wrapper aroundd AddLocals.
 func (pool *TxPool) AddLocal(tx *types.Transaction) error {
 	errs := pool.AddLocals([]*types.Transaction{tx})
-	return errs[0]
+	if len(errs) != 0 {
+		return errs[0]
+	}
+
+	return nil
 }
 
 // AddRemotes enqueues a batch of transactions into the pool if they are valid. If the
@@ -972,7 +977,11 @@ func (pool *TxPool) AddRemotesSync(txs []*types.Transaction) []error {
 // This is like AddRemotes with a single transaction, but waits for pool reorganization. Tests use this method.
 func (pool *TxPool) addRemoteSync(tx *types.Transaction) error {
 	errs := pool.AddRemotesSync([]*types.Transaction{tx})
-	return errs[0]
+	if len(errs) != 0 {
+		return errs[0]
+	}
+
+	return nil
 }
 
 // AddRemote enqueues a single transaction into the pool if it is valid. This is a convenience
@@ -981,15 +990,42 @@ func (pool *TxPool) addRemoteSync(tx *types.Transaction) error {
 // Deprecated: use AddRemotes
 func (pool *TxPool) AddRemote(tx *types.Transaction) error {
 	errs := pool.AddRemotes([]*types.Transaction{tx})
-	return errs[0]
+	if len(errs) != 0 {
+		return errs[0]
+	}
+
+	return nil
+}
+
+type TxError struct {
+	Index int
+	Err   error
+}
+
+func (te TxError) Is(target error) bool {
+	t, ok := target.(*TxError)
+	if !ok {
+		return false
+	}
+
+	return te.Index == t.Index && errors.Is(te.Err, t.Err)
+}
+
+func (te TxError) Unwrap() error {
+	return te.Err
+}
+
+func (te TxError) Error() string {
+	return fmt.Sprintf("index %d, error %v", te.Index, te.Err)
 }
 
 // addTxs attempts to queue a batch of transactions if they are valid.
 func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 	// Filter out known ones without obtaining the pool lock or recovering signatures
 	var (
-		errs = make([]error, len(txs))
+		errs []error
 		news = make([]*types.Transaction, 0, len(txs))
+		err  error
 
 		hash common.Hash
 	)
@@ -997,45 +1033,44 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 	for i, tx := range txs {
 		// If the transaction is known, pre-set the error slot
 		hash = tx.Hash()
+
 		if pool.all.Get(hash) != nil {
-			errs[i] = ErrAlreadyKnown
+			errs = append(errs, TxError{i, ErrAlreadyKnown})
 			knownTxMeter.Mark(1)
+
 			continue
 		}
+
 		// Exclude transactions with invalid signatures as soon as
 		// possible and cache senders in transactions before
 		// obtaining lock
-		_, err := types.Sender(pool.signer, tx)
+		_, err = types.Sender(pool.signer, tx)
 		if err != nil {
-			errs[i] = ErrInvalidSender
+			errs = append(errs, TxError{i, ErrInvalidSender})
 			invalidTxMeter.Mark(1)
+
 			continue
 		}
+
 		// Accumulate all unknown transactions for deeper processing
 		news = append(news, tx)
 	}
+
 	if len(news) == 0 {
 		return errs
 	}
 
 	// Process all the new transaction and merge any errors into the original slice
 	pool.mu.Lock()
-	newErrs, dirtyAddrs := pool.addTxsLocked(news, local)
+	errs, dirtyAddrs := pool.addTxsLocked(news, local)
 	pool.mu.Unlock()
 
-	var nilSlot = 0
-	for _, err := range newErrs {
-		for errs[nilSlot] != nil {
-			nilSlot++
-		}
-		errs[nilSlot] = err
-		nilSlot++
-	}
 	// Reorg the pool internals if needed and return
 	done := pool.requestPromoteExecutables(dirtyAddrs)
 	if sync {
 		<-done
 	}
+
 	return errs
 }
 
@@ -1043,20 +1078,27 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 // The transaction pool lock must be held.
 func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error, *accountSet) {
 	dirty := newAccountSet(pool.signer)
-	errs := make([]error, len(txs))
 
 	var (
 		replaced bool
+		errs     []error
 	)
 
 	for i, tx := range txs {
-		replaced, errs[i] = pool.add(tx, local)
-		if errs[i] == nil && !replaced {
+		var err error
+
+		replaced, err = pool.add(tx, local)
+		if err == nil && !replaced {
 			dirty.addTx(tx)
 		}
+
+		if err != nil {
+			errs = append(errs, TxError{i, err})
+		}
 	}
 
 	validTxMeter.Mark(int64(len(dirty.accounts)))
+
 	return errs, dirty
 }
 
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 28eaf6d466..aaecf0897a 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -336,7 +336,7 @@ func TestInvalidTransactions(t *testing.T) {
 	tx = transaction(1, 100000, key)
 	pool.gasPrice = big.NewInt(1000)
 	pool.gasPriceUint = uint256.NewInt(1000)
-	if err := pool.AddRemote(tx); err != ErrUnderpriced {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Error("expected", ErrUnderpriced, "got", err)
 	}
 	if err := pool.AddLocal(tx); err != nil {
@@ -421,7 +421,7 @@ func TestTransactionNegativeValue(t *testing.T) {
 	tx, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(-1), 100, big.NewInt(1), nil), types.HomesteadSigner{}, key)
 	from, _ := deriveSender(tx)
 	testAddBalance(pool, from, big.NewInt(1))
-	if err := pool.AddRemote(tx); err != ErrNegativeValue {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrNegativeValue) {
 		t.Error("expected", ErrNegativeValue, "got", err)
 	}
 }
@@ -434,7 +434,7 @@ func TestTransactionTipAboveFeeCap(t *testing.T) {
 
 	tx := dynamicFeeTx(0, 100, big.NewInt(1), big.NewInt(2), key)
 
-	if err := pool.AddRemote(tx); err != ErrTipAboveFeeCap {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrTipAboveFeeCap) {
 		t.Error("expected", ErrTipAboveFeeCap, "got", err)
 	}
 }
@@ -449,12 +449,12 @@ func TestTransactionVeryHighValues(t *testing.T) {
 	veryBigNumber.Lsh(veryBigNumber, 300)
 
 	tx := dynamicFeeTx(0, 100, big.NewInt(1), veryBigNumber, key)
-	if err := pool.AddRemote(tx); err != ErrTipVeryHigh {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrTipVeryHigh) {
 		t.Error("expected", ErrTipVeryHigh, "got", err)
 	}
 
 	tx2 := dynamicFeeTx(0, 100, veryBigNumber, big.NewInt(1), key)
-	if err := pool.AddRemote(tx2); err != ErrFeeCapVeryHigh {
+	if err := pool.AddRemote(tx2); !errors.Is(err, ErrFeeCapVeryHigh) {
 		t.Error("expected", ErrFeeCapVeryHigh, "got", err)
 	}
 }
@@ -1005,6 +1005,7 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) {
 	for i := uint64(0); i < 3*config.GlobalQueue; i++ {
 		txs = append(txs, transaction(i+1, 100000, local))
 	}
+
 	pool.AddLocals(txs)
 
 	// If locals are disabled, the previous eviction algorithm should apply here too
@@ -1499,13 +1500,13 @@ func TestTransactionPoolRepricing(t *testing.T) {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
 	// Check that we can't add the old transactions back
-	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), keys[0])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), keys[0])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), keys[2])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), keys[2])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced queued transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	if err := validateEvents(events, 0); err != nil {
@@ -1621,15 +1622,15 @@ func TestTransactionPoolRepricingDynamicFee(t *testing.T) {
 	}
 	// Check that we can't add the old transactions back
 	tx := pricedTransaction(1, 100000, big.NewInt(1), keys[0])
-	if err := pool.AddRemote(tx); err != ErrUnderpriced {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	tx = dynamicFeeTx(0, 100000, big.NewInt(2), big.NewInt(1), keys[1])
-	if err := pool.AddRemote(tx); err != ErrUnderpriced {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	tx = dynamicFeeTx(2, 100000, big.NewInt(1), big.NewInt(1), keys[2])
-	if err := pool.AddRemote(tx); err != ErrUnderpriced {
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced queued transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	if err := validateEvents(events, 0); err != nil {
@@ -1801,7 +1802,7 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
 	// Ensure that adding an underpriced transaction on block limit fails
-	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	// Ensure that adding high priced transactions drops cheap ones, but not own
@@ -1973,7 +1974,7 @@ func TestTransactionPoolUnderpricingDynamicFee(t *testing.T) {
 
 	// Ensure that adding an underpriced transaction fails
 	tx := dynamicFeeTx(0, 100000, big.NewInt(2), big.NewInt(1), keys[1])
-	if err := pool.AddRemote(tx); err != ErrUnderpriced { // Pend K0:0, K0:1, K2:0; Que K1:1
+	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) { // Pend K0:0, K0:1, K2:0; Que K1:1
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 
@@ -2110,8 +2111,8 @@ func TestTransactionDeduplication(t *testing.T) {
 		firsts = append(firsts, txs[i])
 	}
 	errs := pool.AddRemotesSync(firsts)
-	if len(errs) != len(firsts) {
-		t.Fatalf("first add mismatching result count: have %d, want %d", len(errs), len(firsts))
+	if len(errs) != 0 {
+		t.Fatalf("first add mismatching result count: have %d, want %d", len(errs), 0)
 	}
 	for i, err := range errs {
 		if err != nil {
@@ -2127,8 +2128,8 @@ func TestTransactionDeduplication(t *testing.T) {
 	}
 	// Try to add all of them now and ensure previous ones error out as knowns
 	errs = pool.AddRemotesSync(txs)
-	if len(errs) != len(txs) {
-		t.Fatalf("all add mismatching result count: have %d, want %d", len(errs), len(txs))
+	if len(errs) != 0 {
+		t.Fatalf("all add mismatching result count: have %d, want %d", len(errs), 0)
 	}
 	for i, err := range errs {
 		if i%2 == 0 && err == nil {
@@ -2178,7 +2179,7 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.addRemoteSync(pricedTransaction(0, 100000, big.NewInt(1), key)); err != nil {
 		t.Fatalf("failed to add original cheap pending transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original cheap pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
 	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(2), key)); err != nil {
@@ -2191,7 +2192,7 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.addRemoteSync(pricedTransaction(0, 100000, big.NewInt(price), key)); err != nil {
 		t.Fatalf("failed to add original proper pending transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(threshold-1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original proper pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
 	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(threshold), key)); err != nil {
@@ -2205,7 +2206,7 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), key)); err != nil {
 		t.Fatalf("failed to add original cheap queued transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original cheap queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(2), key)); err != nil {
@@ -2215,7 +2216,7 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(price), key)); err != nil {
 		t.Fatalf("failed to add original proper queued transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(threshold-1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original proper queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(threshold), key)); err != nil {
@@ -2279,7 +2280,7 @@ func TestTransactionReplacementDynamicFee(t *testing.T) {
 		}
 		// 2.  Don't bump tip or feecap => discard
 		tx = dynamicFeeTx(nonce, 100001, big.NewInt(2), big.NewInt(1), key)
-		if err := pool.AddRemote(tx); err != ErrReplaceUnderpriced {
+		if err := pool.AddRemote(tx); !errors.Is(err, ErrReplaceUnderpriced) {
 			t.Fatalf("original cheap %s transaction replacement error mismatch: have %v, want %v", stage, err, ErrReplaceUnderpriced)
 		}
 		// 3.  Bump both more than min => accept
@@ -2302,22 +2303,22 @@ func TestTransactionReplacementDynamicFee(t *testing.T) {
 		}
 		// 6.  Bump tip max allowed so it's still underpriced => discard
 		tx = dynamicFeeTx(nonce, 100000, big.NewInt(gasFeeCap), big.NewInt(tipThreshold-1), key)
-		if err := pool.AddRemote(tx); err != ErrReplaceUnderpriced {
+		if err := pool.AddRemote(tx); !errors.Is(err, ErrReplaceUnderpriced) {
 			t.Fatalf("original proper %s transaction replacement error mismatch: have %v, want %v", stage, err, ErrReplaceUnderpriced)
 		}
 		// 7.  Bump fee cap max allowed so it's still underpriced => discard
 		tx = dynamicFeeTx(nonce, 100000, big.NewInt(feeCapThreshold-1), big.NewInt(gasTipCap), key)
-		if err := pool.AddRemote(tx); err != ErrReplaceUnderpriced {
+		if err := pool.AddRemote(tx); !errors.Is(err, ErrReplaceUnderpriced) {
 			t.Fatalf("original proper %s transaction replacement error mismatch: have %v, want %v", stage, err, ErrReplaceUnderpriced)
 		}
 		// 8.  Bump tip min for acceptance => accept
 		tx = dynamicFeeTx(nonce, 100000, big.NewInt(gasFeeCap), big.NewInt(tipThreshold), key)
-		if err := pool.AddRemote(tx); err != ErrReplaceUnderpriced {
+		if err := pool.AddRemote(tx); !errors.Is(err, ErrReplaceUnderpriced) {
 			t.Fatalf("original proper %s transaction replacement error mismatch: have %v, want %v", stage, err, ErrReplaceUnderpriced)
 		}
 		// 9.  Bump fee cap min for acceptance => accept
 		tx = dynamicFeeTx(nonce, 100000, big.NewInt(feeCapThreshold), big.NewInt(gasTipCap), key)
-		if err := pool.AddRemote(tx); err != ErrReplaceUnderpriced {
+		if err := pool.AddRemote(tx); !errors.Is(err, ErrReplaceUnderpriced) {
 			t.Fatalf("original proper %s transaction replacement error mismatch: have %v, want %v", stage, err, ErrReplaceUnderpriced)
 		}
 		// 10. Check events match expected (3 new executable txs during pending, 0 during queue)
@@ -2723,9 +2724,12 @@ func BenchmarkPoolMultiAccountBatchInsertRace(b *testing.B) {
 
 func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
-	pool, _ := setupTxPool()
+	pendingAddedCh := make(chan struct{}, 1024)
+	pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
 	defer pool.Stop()
 
+	_ = localKey
+
 	batches := make(types.Transactions, b.N)
 
 	for i := 0; i < b.N; i++ {
@@ -2746,17 +2750,15 @@ func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
 
 		var pending map[common.Address]types.Transactions
 
-	loop:
-		for {
-			select {
-			case <-t.C:
-				pending = pool.Pending(true)
-			case <-done:
-				break loop
+		for range t.C {
+			pending = pool.Pending(true)
+
+			if len(pending) >= b.N/2 {
+				close(done)
+
+				return
 			}
 		}
-
-		fmt.Fprint(io.Discard, pending)
 	}()
 
 	b.ReportAllocs()
@@ -2766,9 +2768,7 @@ func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
 		pool.AddRemotes([]*types.Transaction{tx})
 	}
 
-	close(done)
-
-	time.Sleep(10 * time.Second)
+	<-done
 }
 
 func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
@@ -2784,8 +2784,8 @@ func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 	batchesSecond := make(types.Transactions, n)
 
 	for i := 0; i < n; i++ {
-		batches[i] = newTx(pool)
-		batchesSecond[i] = newTx(pool)
+		batches[i] = newTxs(pool)
+		batchesSecond[i] = newTxs(pool)
 	}
 
 	done := make(chan struct{})
@@ -2796,21 +2796,21 @@ func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 
 		var (
 			pending map[common.Address]types.Transactions
-			locals  []common.Address
+			total   int
 		)
 
-	loop:
-		for {
-			select {
-			case <-t.C:
-				pending = pool.Pending(true)
-				locals = pool.Locals()
-			case <-done:
-				break loop
+		for range t.C {
+			pending = pool.Pending(true)
+			total = len(pending)
+
+			_ = pool.Locals()
+
+			if total >= n {
+				close(done)
+
+				return
 			}
 		}
-
-		fmt.Fprint(io.Discard, pending, locals)
 	}()
 
 	for _, tx := range batches {
@@ -2821,15 +2821,15 @@ func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 		pool.AddRemotes([]*types.Transaction{tx})
 	}
 
-	close(done)
+	<-done
 }
 
-func newTx(pool *TxPool) *types.Transaction {
+func newTxs(pool *TxPool) *types.Transaction {
 	key, _ := crypto.GenerateKey()
 	account := crypto.PubkeyToAddress(key.PublicKey)
 	tx := transaction(uint64(0), 100000, key)
 
-	pool.currentState.AddBalance(account, big.NewInt(1000000))
+	pool.currentState.AddBalance(account, big.NewInt(1_000_000_000))
 
 	return tx
 }
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 66330e3bfb..cf99179391 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -326,7 +326,7 @@ func (tx *Transaction) GasFeeCapCmp(other *Transaction) int {
 }
 
 func (tx *Transaction) GasFeeCapIntCmp(other *big.Int) int {
-	return tx.inner.gasTipCap().Cmp(other)
+	return tx.inner.gasFeeCap().Cmp(other)
 }
 
 func (tx *Transaction) GasFeeCapUIntCmp(other *uint256.Int) int {
diff --git a/eth/api_backend.go b/eth/api_backend.go
index c33f3cf6f2..4e6db32fe1 100644
--- a/eth/api_backend.go
+++ b/eth/api_backend.go
@@ -236,7 +236,14 @@ func (b *EthAPIBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscri
 }
 
 func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error {
-	return b.eth.txPool.AddLocal(signedTx)
+	err := b.eth.txPool.AddLocal(signedTx)
+	if err != nil {
+		if unwrapped := errors.Unwrap(err); unwrapped != nil {
+			return unwrapped
+		}
+	}
+
+	return err
 }
 
 func (b *EthAPIBackend) GetPoolTransactions() (types.Transactions, error) {

From dd83fa224553188f3419a326b587e27785acddab Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 20:58:21 +0400
Subject: [PATCH 41/96] linters

---
 core/tx_pool_test.go | 82 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index aaecf0897a..68fca305af 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -336,9 +336,11 @@ func TestInvalidTransactions(t *testing.T) {
 	tx = transaction(1, 100000, key)
 	pool.gasPrice = big.NewInt(1000)
 	pool.gasPriceUint = uint256.NewInt(1000)
+
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Error("expected", ErrUnderpriced, "got", err)
 	}
+
 	if err := pool.AddLocal(tx); err != nil {
 		t.Error("expected", nil, "got", err)
 	}
@@ -420,7 +422,9 @@ func TestTransactionNegativeValue(t *testing.T) {
 
 	tx, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(-1), 100, big.NewInt(1), nil), types.HomesteadSigner{}, key)
 	from, _ := deriveSender(tx)
+
 	testAddBalance(pool, from, big.NewInt(1))
+
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrNegativeValue) {
 		t.Error("expected", ErrNegativeValue, "got", err)
 	}
@@ -1474,15 +1478,19 @@ func TestTransactionPoolRepricing(t *testing.T) {
 	if pending != 7 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 7)
 	}
+
 	if queued != 3 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 3)
 	}
+
 	if err := validateEvents(events, 7); err != nil {
 		t.Fatalf("original event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// Reprice the pool and check that underpriced transactions get dropped
 	pool.SetGasPrice(big.NewInt(2))
 
@@ -1490,58 +1498,76 @@ func TestTransactionPoolRepricing(t *testing.T) {
 	if pending != 2 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
 	}
+
 	if queued != 5 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 5)
 	}
+
 	if err := validateEvents(events, 0); err != nil {
 		t.Fatalf("reprice event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// Check that we can't add the old transactions back
 	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), keys[0])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), keys[2])); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced queued transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
+
 	if err := validateEvents(events, 0); err != nil {
 		t.Fatalf("post-reprice event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// However we can add local underpriced transactions
 	tx := pricedTransaction(1, 100000, big.NewInt(1), keys[3])
+
 	if err := pool.AddLocal(tx); err != nil {
 		t.Fatalf("failed to add underpriced local transaction: %v", err)
 	}
+
 	if pending, _ = pool.Stats(); pending != 3 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
 	}
+
 	if err := validateEvents(events, 1); err != nil {
 		t.Fatalf("post-reprice local event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// And we can fill gaps with properly priced transactions
 	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(2), keys[0])); err != nil {
 		t.Fatalf("failed to add pending transaction: %v", err)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(2), keys[1])); err != nil {
 		t.Fatalf("failed to add pending transaction: %v", err)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(2), keys[2])); err != nil {
 		t.Fatalf("failed to add queued transaction: %v", err)
 	}
+
 	if err := validateEvents(events, 5); err != nil {
 		t.Fatalf("post-reprice event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
@@ -1570,6 +1596,7 @@ func TestTransactionPoolRepricingDynamicFee(t *testing.T) {
 		keys[i], _ = crypto.GenerateKey()
 		testAddBalance(pool, crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
 	}
+
 	// Generate and queue a batch of transactions, both pending and queued
 	txs := types.Transactions{}
 
@@ -1595,15 +1622,19 @@ func TestTransactionPoolRepricingDynamicFee(t *testing.T) {
 	if pending != 7 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 7)
 	}
+
 	if queued != 3 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 3)
 	}
+
 	if err := validateEvents(events, 7); err != nil {
 		t.Fatalf("original event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// Reprice the pool and check that underpriced transactions get dropped
 	pool.SetGasPrice(big.NewInt(2))
 
@@ -1611,64 +1642,87 @@ func TestTransactionPoolRepricingDynamicFee(t *testing.T) {
 	if pending != 2 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
 	}
+
 	if queued != 5 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 5)
 	}
+
 	if err := validateEvents(events, 0); err != nil {
 		t.Fatalf("reprice event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// Check that we can't add the old transactions back
 	tx := pricedTransaction(1, 100000, big.NewInt(1), keys[0])
+
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
+
 	tx = dynamicFeeTx(0, 100000, big.NewInt(2), big.NewInt(1), keys[1])
+
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
+
 	tx = dynamicFeeTx(2, 100000, big.NewInt(1), big.NewInt(1), keys[2])
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Fatalf("adding underpriced queued transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
+
 	if err := validateEvents(events, 0); err != nil {
 		t.Fatalf("post-reprice event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// However we can add local underpriced transactions
 	tx = dynamicFeeTx(1, 100000, big.NewInt(1), big.NewInt(1), keys[3])
+
 	if err := pool.AddLocal(tx); err != nil {
 		t.Fatalf("failed to add underpriced local transaction: %v", err)
 	}
+
 	if pending, _ = pool.Stats(); pending != 3 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
 	}
+
 	if err := validateEvents(events, 1); err != nil {
 		t.Fatalf("post-reprice local event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+
 	// And we can fill gaps with properly priced transactions
 	tx = pricedTransaction(1, 100000, big.NewInt(2), keys[0])
+
 	if err := pool.AddRemote(tx); err != nil {
 		t.Fatalf("failed to add pending transaction: %v", err)
 	}
+
 	tx = dynamicFeeTx(0, 100000, big.NewInt(3), big.NewInt(2), keys[1])
+
 	if err := pool.AddRemote(tx); err != nil {
 		t.Fatalf("failed to add pending transaction: %v", err)
 	}
+
 	tx = dynamicFeeTx(2, 100000, big.NewInt(2), big.NewInt(2), keys[2])
+
 	if err := pool.AddRemote(tx); err != nil {
 		t.Fatalf("failed to add queued transaction: %v", err)
 	}
+
 	if err := validateEvents(events, 5); err != nil {
 		t.Fatalf("post-reprice event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
@@ -2103,49 +2157,65 @@ func TestTransactionDeduplication(t *testing.T) {
 
 	// Create a batch of transactions and add a few of them
 	txs := make([]*types.Transaction, 16)
+
 	for i := 0; i < len(txs); i++ {
 		txs[i] = pricedTransaction(uint64(i), 100000, big.NewInt(1), key)
 	}
+
 	var firsts []*types.Transaction
+
 	for i := 0; i < len(txs); i += 2 {
 		firsts = append(firsts, txs[i])
 	}
+
 	errs := pool.AddRemotesSync(firsts)
+
 	if len(errs) != 0 {
 		t.Fatalf("first add mismatching result count: have %d, want %d", len(errs), 0)
 	}
+
 	for i, err := range errs {
 		if err != nil {
 			t.Errorf("add %d failed: %v", i, err)
 		}
 	}
+
 	pending, queued := pool.Stats()
+
 	if pending != 1 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 1)
 	}
+
 	if queued != len(txs)/2-1 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, len(txs)/2-1)
 	}
+
 	// Try to add all of them now and ensure previous ones error out as knowns
 	errs = pool.AddRemotesSync(txs)
 	if len(errs) != 0 {
 		t.Fatalf("all add mismatching result count: have %d, want %d", len(errs), 0)
 	}
+
 	for i, err := range errs {
 		if i%2 == 0 && err == nil {
 			t.Errorf("add %d succeeded, should have failed as known", i)
 		}
+
 		if i%2 == 1 && err != nil {
 			t.Errorf("add %d failed: %v", i, err)
 		}
 	}
+
 	pending, queued = pool.Stats()
+
 	if pending != len(txs) {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, len(txs))
 	}
+
 	if queued != 0 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
@@ -2179,12 +2249,15 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.addRemoteSync(pricedTransaction(0, 100000, big.NewInt(1), key)); err != nil {
 		t.Fatalf("failed to add original cheap pending transaction: %v", err)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original cheap pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(2), key)); err != nil {
 		t.Fatalf("failed to replace original cheap pending transaction: %v", err)
 	}
+
 	if err := validateEvents(events, 2); err != nil {
 		t.Fatalf("cheap replacement event firing failed: %v", err)
 	}
@@ -2192,12 +2265,15 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.addRemoteSync(pricedTransaction(0, 100000, big.NewInt(price), key)); err != nil {
 		t.Fatalf("failed to add original proper pending transaction: %v", err)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(threshold-1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original proper pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(threshold), key)); err != nil {
 		t.Fatalf("failed to replace original proper pending transaction: %v", err)
 	}
+
 	if err := validateEvents(events, 2); err != nil {
 		t.Fatalf("proper replacement event firing failed: %v", err)
 	}
@@ -2206,9 +2282,11 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), key)); err != nil {
 		t.Fatalf("failed to add original cheap queued transaction: %v", err)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original cheap queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(2), key)); err != nil {
 		t.Fatalf("failed to replace original cheap queued transaction: %v", err)
 	}
@@ -2216,9 +2294,11 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(price), key)); err != nil {
 		t.Fatalf("failed to add original proper queued transaction: %v", err)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(threshold-1), key)); !errors.Is(err, ErrReplaceUnderpriced) {
 		t.Fatalf("original proper queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
+
 	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(threshold), key)); err != nil {
 		t.Fatalf("failed to replace original proper queued transaction: %v", err)
 	}
@@ -2226,6 +2306,7 @@ func TestTransactionReplacement(t *testing.T) {
 	if err := validateEvents(events, 0); err != nil {
 		t.Fatalf("queued replacement event firing failed: %v", err)
 	}
+
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
@@ -2725,6 +2806,7 @@ func BenchmarkPoolMultiAccountBatchInsertRace(b *testing.B) {
 func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
 	pendingAddedCh := make(chan struct{}, 1024)
+
 	pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
 	defer pool.Stop()
 

From 22b8814aeddd4aa4f2555c4e074e1b024a95bde7 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 22:13:24 +0400
Subject: [PATCH 42/96] fix

---
 les/handler_test.go    |  2 +-
 les/server_requests.go | 11 ++++++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/les/handler_test.go b/les/handler_test.go
index aba45764b3..8ead35279e 100644
--- a/les/handler_test.go
+++ b/les/handler_test.go
@@ -617,7 +617,7 @@ func testTransactionStatus(t *testing.T, protocol int) {
 			sendRequest(rawPeer.app, GetTxStatusMsg, reqID, []common.Hash{tx.Hash()})
 		}
 		if err := expectResponse(rawPeer.app, TxStatusMsg, reqID, testBufLimit, []light.TxStatus{expStatus}); err != nil {
-			t.Errorf("transaction status mismatch")
+			t.Error("transaction status mismatch", err)
 		}
 	}
 	signer := types.HomesteadSigner{}
diff --git a/les/server_requests.go b/les/server_requests.go
index bab5f733d5..d11e361e46 100644
--- a/les/server_requests.go
+++ b/les/server_requests.go
@@ -19,6 +19,7 @@ package les
 import (
 	"encoding/binary"
 	"encoding/json"
+	"errors"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -523,7 +524,15 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 					addFn = backend.TxPool().AddRemotesSync
 				}
 				if errs := addFn([]*types.Transaction{tx}); errs[0] != nil {
-					stats[i].Error = errs[0].Error()
+					err := errs[0].Error()
+
+					// we receive a wrapped error
+					if unwrapped := errors.Unwrap(errs[0]); unwrapped != nil {
+						err = unwrapped.Error()
+					}
+
+					stats[i].Error = err
+
 					continue
 				}
 				stats[i] = txStatus(backend, hash)

From 7585c1e775ad84acc3943c4d542a4ca3d4a634ac Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 22 Oct 2022 22:58:03 +0400
Subject: [PATCH 43/96] fix

---
 les/server_requests.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/les/server_requests.go b/les/server_requests.go
index d11e361e46..164ffe19b1 100644
--- a/les/server_requests.go
+++ b/les/server_requests.go
@@ -523,7 +523,7 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				if backend.AddTxsSync() {
 					addFn = backend.TxPool().AddRemotesSync
 				}
-				if errs := addFn([]*types.Transaction{tx}); errs[0] != nil {
+				if errs := addFn([]*types.Transaction{tx}); len(errs) != 0 {
 					err := errs[0].Error()
 
 					// we receive a wrapped error

From df659fcb9f1838e3eadc48ba0443e905b1d079ac Mon Sep 17 00:00:00 2001
From: Evgeny Danilenko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 00:22:24 +0400
Subject: [PATCH 44/96] Linters

---
 les/server_requests.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/les/server_requests.go b/les/server_requests.go
index 164ffe19b1..2444fd8236 100644
--- a/les/server_requests.go
+++ b/les/server_requests.go
@@ -519,10 +519,12 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 			stats[i] = txStatus(backend, hash)
 			if stats[i].Status == core.TxStatusUnknown {
 				addFn := backend.TxPool().AddRemotes
-				// Add txs synchronously for testing purpose
+				
+// Add txs synchronously for testing purpose
 				if backend.AddTxsSync() {
 					addFn = backend.TxPool().AddRemotesSync
 				}
+
 				if errs := addFn([]*types.Transaction{tx}); len(errs) != 0 {
 					err := errs[0].Error()
 

From 8fe4aa9fe838bee5fc0782ec11d0ca7447c1637f Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 10:55:21 +0400
Subject: [PATCH 45/96] linters

---
 les/server_requests.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/les/server_requests.go b/les/server_requests.go
index 164ffe19b1..2ccc0a2946 100644
--- a/les/server_requests.go
+++ b/les/server_requests.go
@@ -523,6 +523,7 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 				if backend.AddTxsSync() {
 					addFn = backend.TxPool().AddRemotesSync
 				}
+
 				if errs := addFn([]*types.Transaction{tx}); len(errs) != 0 {
 					err := errs[0].Error()
 

From d5f7520efcd6d8438a6ba80c38fdbf8d1b6ea191 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 10:56:58 +0400
Subject: [PATCH 46/96] linters

---
 les/server_requests.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/les/server_requests.go b/les/server_requests.go
index 2444fd8236..b7fe162aec 100644
--- a/les/server_requests.go
+++ b/les/server_requests.go
@@ -519,8 +519,8 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 			stats[i] = txStatus(backend, hash)
 			if stats[i].Status == core.TxStatusUnknown {
 				addFn := backend.TxPool().AddRemotes
-				
-// Add txs synchronously for testing purpose
+
+				// Add txs synchronously for testing purpose
 				if backend.AddTxsSync() {
 					addFn = backend.TxPool().AddRemotesSync
 				}

From 9ef42780a88b7907211fdc2119827326e8d518cc Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 15:04:34 +0400
Subject: [PATCH 47/96] simplify errors

---
 core/tx_list.go        |   4 +-
 core/tx_pool.go        | 129 +++++++++++++++++++++++--------------
 core/tx_pool_test.go   | 143 ++++++++++++++++++++++++++++++++++++++---
 les/server_requests.go |  27 ++++----
 4 files changed, 231 insertions(+), 72 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 14132eba92..5e0bf75441 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -268,9 +268,7 @@ func (m *txSortedMap) Flatten() types.Transactions {
 	defer m.m.Unlock()
 
 	// Copy the cache to prevent accidental modifications
-	cache := m.flatten()
-	txs := make(types.Transactions, len(cache))
-	copy(txs, cache)
+	txs := m.flatten()
 
 	return txs
 }
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 929c98a121..62562b573d 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -18,7 +18,6 @@ package core
 
 import (
 	"errors"
-	"fmt"
 	"math"
 	"math/big"
 	"sort"
@@ -952,12 +951,7 @@ func (pool *TxPool) AddLocals(txs []*types.Transaction) []error {
 // AddLocal enqueues a single local transaction into the pool if it is valid. This is
 // a convenience wrapper aroundd AddLocals.
 func (pool *TxPool) AddLocal(tx *types.Transaction) error {
-	errs := pool.AddLocals([]*types.Transaction{tx})
-	if len(errs) != 0 {
-		return errs[0]
-	}
-
-	return nil
+	return pool.addTx(tx, !pool.config.NoLocals, true)
 }
 
 // AddRemotes enqueues a batch of transactions into the pool if they are valid. If the
@@ -974,49 +968,19 @@ func (pool *TxPool) AddRemotesSync(txs []*types.Transaction) []error {
 	return pool.addTxs(txs, false, true)
 }
 
+func (pool *TxPool) AddRemoteSync(txs *types.Transaction) error {
+	return pool.addTx(txs, false, true)
+}
+
 // This is like AddRemotes with a single transaction, but waits for pool reorganization. Tests use this method.
 func (pool *TxPool) addRemoteSync(tx *types.Transaction) error {
-	errs := pool.AddRemotesSync([]*types.Transaction{tx})
-	if len(errs) != 0 {
-		return errs[0]
-	}
-
-	return nil
+	return pool.AddRemoteSync(tx)
 }
 
 // AddRemote enqueues a single transaction into the pool if it is valid. This is a convenience
 // wrapper around AddRemotes.
-//
-// Deprecated: use AddRemotes
 func (pool *TxPool) AddRemote(tx *types.Transaction) error {
-	errs := pool.AddRemotes([]*types.Transaction{tx})
-	if len(errs) != 0 {
-		return errs[0]
-	}
-
-	return nil
-}
-
-type TxError struct {
-	Index int
-	Err   error
-}
-
-func (te TxError) Is(target error) bool {
-	t, ok := target.(*TxError)
-	if !ok {
-		return false
-	}
-
-	return te.Index == t.Index && errors.Is(te.Err, t.Err)
-}
-
-func (te TxError) Unwrap() error {
-	return te.Err
-}
-
-func (te TxError) Error() string {
-	return fmt.Sprintf("index %d, error %v", te.Index, te.Err)
+	return pool.addTx(tx, false, false)
 }
 
 // addTxs attempts to queue a batch of transactions if they are valid.
@@ -1030,12 +994,12 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 		hash common.Hash
 	)
 
-	for i, tx := range txs {
+	for _, tx := range txs {
 		// If the transaction is known, pre-set the error slot
 		hash = tx.Hash()
 
 		if pool.all.Get(hash) != nil {
-			errs = append(errs, TxError{i, ErrAlreadyKnown})
+			errs = append(errs, ErrAlreadyKnown)
 			knownTxMeter.Mark(1)
 
 			continue
@@ -1046,7 +1010,7 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 		// obtaining lock
 		_, err = types.Sender(pool.signer, tx)
 		if err != nil {
-			errs = append(errs, TxError{i, ErrInvalidSender})
+			errs = append(errs, ErrInvalidSender)
 			invalidTxMeter.Mark(1)
 
 			continue
@@ -1074,6 +1038,57 @@ func (pool *TxPool) addTxs(txs []*types.Transaction, local, sync bool) []error {
 	return errs
 }
 
+// addTxs attempts to queue a batch of transactions if they are valid.
+func (pool *TxPool) addTx(tx *types.Transaction, local, sync bool) error {
+	// Filter out known ones without obtaining the pool lock or recovering signatures
+	var (
+		err  error
+		hash common.Hash
+	)
+
+	func() {
+		// If the transaction is known, pre-set the error slot
+		hash = tx.Hash()
+
+		if pool.all.Get(hash) != nil {
+			err = ErrAlreadyKnown
+
+			knownTxMeter.Mark(1)
+
+			return
+		}
+
+		// Exclude transactions with invalid signatures as soon as
+		// possible and cache senders in transactions before
+		// obtaining lock
+		_, err = types.Sender(pool.signer, tx)
+		if err != nil {
+			invalidTxMeter.Mark(1)
+
+			return
+		}
+	}()
+
+	if err != nil {
+		return err
+	}
+
+	var dirtyAddrs *accountSet
+
+	// Process all the new transaction and merge any errors into the original slice
+	pool.mu.Lock()
+	err, dirtyAddrs = pool.addTxLocked(tx, local)
+	pool.mu.Unlock()
+
+	// Reorg the pool internals if needed and return
+	done := pool.requestPromoteExecutables(dirtyAddrs)
+	if sync {
+		<-done
+	}
+
+	return err
+}
+
 // addTxsLocked attempts to queue a batch of transactions if they are valid.
 // The transaction pool lock must be held.
 func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error, *accountSet) {
@@ -1084,7 +1099,7 @@ func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error,
 		errs     []error
 	)
 
-	for i, tx := range txs {
+	for _, tx := range txs {
 		var err error
 
 		replaced, err = pool.add(tx, local)
@@ -1093,7 +1108,7 @@ func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error,
 		}
 
 		if err != nil {
-			errs = append(errs, TxError{i, err})
+			errs = append(errs, err)
 		}
 	}
 
@@ -1102,6 +1117,24 @@ func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) ([]error,
 	return errs, dirty
 }
 
+func (pool *TxPool) addTxLocked(tx *types.Transaction, local bool) (error, *accountSet) {
+	dirty := newAccountSet(pool.signer)
+
+	var (
+		replaced bool
+		err      error
+	)
+
+	replaced, err = pool.add(tx, local)
+	if err == nil && !replaced {
+		dirty.addTx(tx)
+	}
+
+	validTxMeter.Mark(int64(len(dirty.accounts)))
+
+	return err, dirty
+}
+
 // Status returns the status (unknown/pending/queued) of a batch of transactions
 // identified by their hashes.
 func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 68fca305af..27567c66bb 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2732,17 +2732,21 @@ func BenchmarkInsertRemoteWithAllLocals(b *testing.B) {
 }
 
 // Benchmarks the speed of batch transaction insertion in case of multiple accounts.
-func BenchmarkPoolMultiAccountBatchInsert(b *testing.B) {
+func BenchmarkPoolAccountMultiBatchInsert(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
 	pool, _ := setupTxPool()
 	defer pool.Stop()
 
 	batches := make(types.Transactions, b.N)
+
 	for i := 0; i < b.N; i++ {
 		key, _ := crypto.GenerateKey()
 		account := crypto.PubkeyToAddress(key.PublicKey)
+
 		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
 		tx := transaction(uint64(0), 100000, key)
+
 		batches[i] = tx
 	}
 
@@ -2755,7 +2759,7 @@ func BenchmarkPoolMultiAccountBatchInsert(b *testing.B) {
 	}
 }
 
-func BenchmarkPoolMultiAccountBatchInsertRace(b *testing.B) {
+func BenchmarkPoolAccountMultiBatchInsertRace(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
 	pool, _ := setupTxPool()
 	defer pool.Stop()
@@ -2803,7 +2807,7 @@ func BenchmarkPoolMultiAccountBatchInsertRace(b *testing.B) {
 	close(done)
 }
 
-func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
+func BenchmarkPoolAccountMultiBatchInsertNoLockRace(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
 	pendingAddedCh := make(chan struct{}, 1024)
 
@@ -2853,6 +2857,127 @@ func BenchmarkPoolMultiAccountBatchInsertNoLockRace(b *testing.B) {
 	<-done
 }
 
+func BenchmarkPoolAccountsBatchInsert(b *testing.B) {
+	// Generate a batch of transactions to enqueue into the pool
+	pool, _ := setupTxPool()
+	defer pool.Stop()
+
+	batches := make(types.Transactions, b.N)
+	for i := 0; i < b.N; i++ {
+		key, _ := crypto.GenerateKey()
+		account := crypto.PubkeyToAddress(key.PublicKey)
+		pool.currentState.AddBalance(account, big.NewInt(1000000))
+		tx := transaction(uint64(0), 100000, key)
+		batches[i] = tx
+	}
+
+	// Benchmark importing the transactions into the queue
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for _, tx := range batches {
+		_ = pool.AddRemoteSync(tx)
+	}
+}
+
+func BenchmarkPoolAccountsBatchInsertRace(b *testing.B) {
+	// Generate a batch of transactions to enqueue into the pool
+	pool, _ := setupTxPool()
+	defer pool.Stop()
+
+	batches := make(types.Transactions, b.N)
+
+	for i := 0; i < b.N; i++ {
+		key, _ := crypto.GenerateKey()
+		account := crypto.PubkeyToAddress(key.PublicKey)
+		tx := transaction(uint64(0), 100000, key)
+
+		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
+		batches[i] = tx
+	}
+
+	done := make(chan struct{})
+
+	go func() {
+		t := time.NewTicker(time.Microsecond)
+		defer t.Stop()
+
+		var pending map[common.Address]types.Transactions
+
+	loop:
+		for {
+			select {
+			case <-t.C:
+				pending = pool.Pending(true)
+			case <-done:
+				break loop
+			}
+		}
+
+		fmt.Fprint(io.Discard, pending)
+	}()
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for _, tx := range batches {
+		_ = pool.AddRemoteSync(tx)
+	}
+
+	close(done)
+}
+
+func BenchmarkPoolAccountsBatchInsertNoLockRace(b *testing.B) {
+	// Generate a batch of transactions to enqueue into the pool
+	pendingAddedCh := make(chan struct{}, 1024)
+
+	pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
+	defer pool.Stop()
+
+	_ = localKey
+
+	batches := make(types.Transactions, b.N)
+
+	for i := 0; i < b.N; i++ {
+		key, _ := crypto.GenerateKey()
+		account := crypto.PubkeyToAddress(key.PublicKey)
+		tx := transaction(uint64(0), 100000, key)
+
+		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
+		batches[i] = tx
+	}
+
+	done := make(chan struct{})
+
+	go func() {
+		t := time.NewTicker(time.Microsecond)
+		defer t.Stop()
+
+		var pending map[common.Address]types.Transactions
+
+		for range t.C {
+			pending = pool.Pending(true)
+
+			if len(pending) >= b.N/2 {
+				close(done)
+
+				return
+			}
+		}
+	}()
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for _, tx := range batches {
+		_ = pool.AddRemote(tx)
+	}
+
+	<-done
+}
+
 func TestPoolMultiAccountBatchInsertRace(t *testing.T) {
 	t.Parallel()
 
@@ -3202,20 +3327,20 @@ func testPoolBatchInsert(t *testing.T, cfg txPoolRapidConfig) {
 				wg.Wait()
 
 				var (
-					addIntoTxPool func(tx []*types.Transaction) []error
+					addIntoTxPool func(tx *types.Transaction) error
 					totalInBatch  int
 				)
 
 				for _, tx := range txs.txs {
-					addIntoTxPool = pool.AddRemotesSync
+					addIntoTxPool = pool.AddRemoteSync
 
 					if tx.isLocal {
-						addIntoTxPool = pool.AddLocals
+						addIntoTxPool = pool.AddLocal
 					}
 
-					err := addIntoTxPool([]*types.Transaction{tx.tx})
-					if len(err) != 0 && err[0] != nil {
-						rt.Log("on adding a transaction to the tx pool", err[0], tx.tx.Gas(), tx.tx.GasPrice(), pool.GasPrice(), getBalance(pool, keys[tx.idx].account))
+					err := addIntoTxPool(tx.tx)
+					if err != nil {
+						rt.Log("on adding a transaction to the tx pool", err, tx.tx.Gas(), tx.tx.GasPrice(), pool.GasPrice(), getBalance(pool, keys[tx.idx].account))
 					}
 				}
 
diff --git a/les/server_requests.go b/les/server_requests.go
index b7fe162aec..dbabbbb72a 100644
--- a/les/server_requests.go
+++ b/les/server_requests.go
@@ -19,7 +19,6 @@ package les
 import (
 	"encoding/binary"
 	"encoding/json"
-	"errors"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -508,35 +507,39 @@ func handleSendTx(msg Decoder) (serveRequestFn, uint64, uint64, error) {
 	if err := msg.Decode(&r); err != nil {
 		return nil, 0, 0, err
 	}
+
 	amount := uint64(len(r.Txs))
+
 	return func(backend serverBackend, p *clientPeer, waitOrStop func() bool) *reply {
 		stats := make([]light.TxStatus, len(r.Txs))
+
+		var (
+			err   error
+			addFn func(transaction *types.Transaction) error
+		)
+
 		for i, tx := range r.Txs {
 			if i != 0 && !waitOrStop() {
 				return nil
 			}
+
 			hash := tx.Hash()
 			stats[i] = txStatus(backend, hash)
+
 			if stats[i].Status == core.TxStatusUnknown {
-				addFn := backend.TxPool().AddRemotes
+				addFn = backend.TxPool().AddRemote
 
 				// Add txs synchronously for testing purpose
 				if backend.AddTxsSync() {
-					addFn = backend.TxPool().AddRemotesSync
+					addFn = backend.TxPool().AddRemoteSync
 				}
 
-				if errs := addFn([]*types.Transaction{tx}); len(errs) != 0 {
-					err := errs[0].Error()
-
-					// we receive a wrapped error
-					if unwrapped := errors.Unwrap(errs[0]); unwrapped != nil {
-						err = unwrapped.Error()
-					}
-
-					stats[i].Error = err
+				if err = addFn(tx); err != nil {
+					stats[i].Error = err.Error()
 
 					continue
 				}
+
 				stats[i] = txStatus(backend, hash)
 			}
 		}

From c052514ca2c900a0c490688ebb3c79bc628328ff Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 16:43:38 +0400
Subject: [PATCH 48/96] atomics for transactions

---
 core/tx_pool_test.go              | 69 ++++++++++++++++++++-----------
 core/types/transaction.go         | 22 ++++++----
 core/types/transaction_signing.go |  9 ++--
 3 files changed, 65 insertions(+), 35 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 27567c66bb..b1a3b93f74 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2661,15 +2661,7 @@ func benchmarkFuturePromotion(b *testing.B, size int) {
 }
 
 // Benchmarks the speed of batched transaction insertion.
-func BenchmarkPoolBatchInsert100(b *testing.B)   { benchmarkPoolBatchInsert(b, 100, false) }
-func BenchmarkPoolBatchInsert1000(b *testing.B)  { benchmarkPoolBatchInsert(b, 1000, false) }
-func BenchmarkPoolBatchInsert10000(b *testing.B) { benchmarkPoolBatchInsert(b, 10000, false) }
-
-func BenchmarkPoolBatchLocalInsert100(b *testing.B)   { benchmarkPoolBatchInsert(b, 100, true) }
-func BenchmarkPoolBatchLocalInsert1000(b *testing.B)  { benchmarkPoolBatchInsert(b, 1000, true) }
-func BenchmarkPoolBatchLocalInsert10000(b *testing.B) { benchmarkPoolBatchInsert(b, 10000, true) }
-
-func benchmarkPoolBatchInsert(b *testing.B, size int, local bool) {
+func BenchmarkPoolBatchInsert(b *testing.B) {
 	// Generate a batch of transactions to enqueue into the pool
 	pool, key := setupTxPool()
 	defer pool.Stop()
@@ -2677,22 +2669,53 @@ func benchmarkPoolBatchInsert(b *testing.B, size int, local bool) {
 	account := crypto.PubkeyToAddress(key.PublicKey)
 	testAddBalance(pool, account, big.NewInt(1000000))
 
-	batches := make([]types.Transactions, b.N)
-	for i := 0; i < b.N; i++ {
-		batches[i] = make(types.Transactions, size)
-		for j := 0; j < size; j++ {
-			batches[i][j] = transaction(uint64(size*i+j), 100000, key)
-		}
+	const format = "size %d, is local %t"
+
+	cases := []struct {
+		name    string
+		size    int
+		isLocal bool
+	}{
+		{size: 100, isLocal: false},
+		{size: 1000, isLocal: false},
+		{size: 10000, isLocal: false},
+
+		{size: 100, isLocal: true},
+		{size: 1000, isLocal: true},
+		{size: 10000, isLocal: true},
 	}
+
+	for _, testCase := range cases {
+		testCase.name = fmt.Sprintf(format, testCase.size, testCase.isLocal)
+	}
+
 	// Benchmark importing the transactions into the queue
-	b.ResetTimer()
-	b.ReportAllocs()
-	for _, batch := range batches {
-		if local {
-			pool.AddLocals(batch)
-		} else {
-			pool.AddRemotes(batch)
-		}
+
+	for _, testCase := range cases {
+		testCase := testCase
+
+		b.Run(testCase.name, func(b *testing.B) {
+			batches := make([]types.Transactions, b.N)
+
+			for i := 0; i < b.N; i++ {
+				batches[i] = make(types.Transactions, testCase.size)
+
+				for j := 0; j < testCase.size; j++ {
+					batches[i][j] = transaction(uint64(testCase.size*i+j), 100000, key)
+				}
+			}
+
+			b.ResetTimer()
+			b.ReportAllocs()
+
+			for _, batch := range batches {
+				if testCase.isLocal {
+					pool.AddLocals(batch)
+				} else {
+					pool.AddRemotes(batch)
+				}
+			}
+		})
 	}
 }
 
diff --git a/core/types/transaction.go b/core/types/transaction.go
index cf99179391..0169536981 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -55,9 +55,9 @@ type Transaction struct {
 	time  time.Time // Time first seen locally (spam avoidance)
 
 	// caches
-	hash atomic.Value
-	size atomic.Value
-	from atomic.Value
+	hash atomic.Pointer[common.Hash]
+	size atomic.Pointer[common.StorageSize]
+	from atomic.Pointer[sigCache]
 }
 
 // NewTx creates a new transaction.
@@ -199,7 +199,8 @@ func (tx *Transaction) setDecoded(inner TxData, size int) {
 	tx.inner = inner
 	tx.time = time.Now()
 	if size > 0 {
-		tx.size.Store(common.StorageSize(size))
+		v := float64(size)
+		tx.size.Store((*common.StorageSize)(&v))
 	}
 }
 
@@ -396,7 +397,7 @@ func (tx *Transaction) EffectiveGasTipIntCmp(other *big.Int, baseFee *big.Int) i
 // Hash returns the transaction hash.
 func (tx *Transaction) Hash() common.Hash {
 	if hash := tx.hash.Load(); hash != nil {
-		return hash.(common.Hash)
+		return *hash
 	}
 
 	var h common.Hash
@@ -405,7 +406,9 @@ func (tx *Transaction) Hash() common.Hash {
 	} else {
 		h = prefixedRlpHash(tx.Type(), tx.inner)
 	}
-	tx.hash.Store(h)
+
+	tx.hash.Store(&h)
+
 	return h
 }
 
@@ -413,11 +416,14 @@ func (tx *Transaction) Hash() common.Hash {
 // encoding and returning it, or returning a previously cached value.
 func (tx *Transaction) Size() common.StorageSize {
 	if size := tx.size.Load(); size != nil {
-		return size.(common.StorageSize)
+		return *size
 	}
+
 	c := writeCounter(0)
+
 	rlp.Encode(&c, &tx.inner)
-	tx.size.Store(common.StorageSize(c))
+	tx.size.Store((*common.StorageSize)(&c))
+
 	return common.StorageSize(c)
 }
 
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index 8db736e751..959aba637a 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -130,12 +130,11 @@ func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction
 // not match the signer used in the current call.
 func Sender(signer Signer, tx *Transaction) (common.Address, error) {
 	if sc := tx.from.Load(); sc != nil {
-		sigCache := sc.(sigCache)
 		// If the signer used to derive from in a previous
 		// call is not the same as used current, invalidate
 		// the cache.
-		if sigCache.signer.Equal(signer) {
-			return sigCache.from, nil
+		if sc.signer.Equal(signer) {
+			return sc.from, nil
 		}
 	}
 
@@ -143,7 +142,9 @@ func Sender(signer Signer, tx *Transaction) (common.Address, error) {
 	if err != nil {
 		return common.Address{}, err
 	}
-	tx.from.Store(sigCache{signer: signer, from: addr})
+
+	tx.from.Store(&sigCache{signer: signer, from: addr})
+
 	return addr, nil
 }
 

From 5866cd56a04212cf5f5a53b0dba51a3037a74f76 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 16:54:37 +0400
Subject: [PATCH 49/96] fix

---
 core/tx_pool_test.go | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index b1a3b93f74..80d4ec6ff8 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2685,23 +2685,23 @@ func BenchmarkPoolBatchInsert(b *testing.B) {
 		{size: 10000, isLocal: true},
 	}
 
-	for _, testCase := range cases {
-		testCase.name = fmt.Sprintf(format, testCase.size, testCase.isLocal)
+	for i := range cases {
+		cases[i].name = fmt.Sprintf(format, cases[i].size, cases[i].isLocal)
 	}
 
 	// Benchmark importing the transactions into the queue
 
 	for _, testCase := range cases {
-		testCase := testCase
+		singleCase := testCase
 
-		b.Run(testCase.name, func(b *testing.B) {
+		b.Run(singleCase.name, func(b *testing.B) {
 			batches := make([]types.Transactions, b.N)
 
 			for i := 0; i < b.N; i++ {
-				batches[i] = make(types.Transactions, testCase.size)
+				batches[i] = make(types.Transactions, singleCase.size)
 
-				for j := 0; j < testCase.size; j++ {
-					batches[i][j] = transaction(uint64(testCase.size*i+j), 100000, key)
+				for j := 0; j < singleCase.size; j++ {
+					batches[i][j] = transaction(uint64(singleCase.size*i+j), 100000, key)
 				}
 			}
 
@@ -2886,11 +2886,15 @@ func BenchmarkPoolAccountsBatchInsert(b *testing.B) {
 	defer pool.Stop()
 
 	batches := make(types.Transactions, b.N)
+
 	for i := 0; i < b.N; i++ {
 		key, _ := crypto.GenerateKey()
 		account := crypto.PubkeyToAddress(key.PublicKey)
+
 		pool.currentState.AddBalance(account, big.NewInt(1000000))
+
 		tx := transaction(uint64(0), 100000, key)
+
 		batches[i] = tx
 	}
 

From ab36c330ac8a89b66d80ceae0e8e3400825a0cd1 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 21:21:22 +0400
Subject: [PATCH 50/96] optimize workers

---
 common/math/big.go             |  29 ++++++--
 common/math/uint.go            |   9 +++
 consensus/misc/eip1559.go      |  52 ++++++++++++++
 consensus/misc/eip1559_test.go |  30 ++++++++
 core/tx_list.go                |   9 +--
 core/tx_pool.go                |   6 +-
 core/tx_pool_test.go           | 125 ++++++++++++++++++++++++++++++++-
 core/types/transaction.go      |  83 ++++++++++++++++++++--
 miner/worker.go                |  13 ++--
 9 files changed, 335 insertions(+), 21 deletions(-)

diff --git a/common/math/big.go b/common/math/big.go
index 1af5b4d879..4ccf89e38c 100644
--- a/common/math/big.go
+++ b/common/math/big.go
@@ -20,6 +20,8 @@ package math
 import (
 	"fmt"
 	"math/big"
+
+	"github.com/holiman/uint256"
 )
 
 // Various big integer limit values.
@@ -132,6 +134,7 @@ func MustParseBig256(s string) *big.Int {
 // BigPow returns a ** b as a big integer.
 func BigPow(a, b int64) *big.Int {
 	r := big.NewInt(a)
+
 	return r.Exp(r, big.NewInt(b), nil)
 }
 
@@ -140,6 +143,15 @@ func BigMax(x, y *big.Int) *big.Int {
 	if x.Cmp(y) < 0 {
 		return y
 	}
+
+	return x
+}
+
+func BigMaxUint(x, y *uint256.Int) *uint256.Int {
+	if x.Lt(y) {
+		return y
+	}
+
 	return x
 }
 
@@ -148,6 +160,15 @@ func BigMin(x, y *big.Int) *big.Int {
 	if x.Cmp(y) > 0 {
 		return y
 	}
+
+	return x
+}
+
+func BigMinUint256(x, y *uint256.Int) *uint256.Int {
+	if x.Gt(y) {
+		return y
+	}
+
 	return x
 }
 
@@ -227,10 +248,10 @@ func U256Bytes(n *big.Int) []byte {
 // S256 interprets x as a two's complement number.
 // x must not exceed 256 bits (the result is undefined if it does) and is not modified.
 //
-//   S256(0)        = 0
-//   S256(1)        = 1
-//   S256(2**255)   = -2**255
-//   S256(2**256-1) = -1
+//	S256(0)        = 0
+//	S256(1)        = 1
+//	S256(2**255)   = -2**255
+//	S256(2**256-1) = -1
 func S256(x *big.Int) *big.Int {
 	if x.Cmp(tt255) < 0 {
 		return x
diff --git a/common/math/uint.go b/common/math/uint.go
index dad9618953..96b8261884 100644
--- a/common/math/uint.go
+++ b/common/math/uint.go
@@ -1,10 +1,13 @@
 package math
 
 import (
+	"math/big"
+
 	"github.com/holiman/uint256"
 )
 
 var (
+	U0   = uint256.NewInt(0)
 	U1   = uint256.NewInt(1)
 	U100 = uint256.NewInt(100)
 )
@@ -12,3 +15,9 @@ var (
 func U256LTE(a, b *uint256.Int) bool {
 	return a.Lt(b) || a.Eq(b)
 }
+
+func FromBig(v *big.Int) *uint256.Int {
+	u, _ := uint256.FromBig(v)
+
+	return u
+}
diff --git a/consensus/misc/eip1559.go b/consensus/misc/eip1559.go
index 8fca0fdc70..47baee4c88 100644
--- a/consensus/misc/eip1559.go
+++ b/consensus/misc/eip1559.go
@@ -20,6 +20,8 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -91,3 +93,53 @@ func CalcBaseFee(config *params.ChainConfig, parent *types.Header) *big.Int {
 		)
 	}
 }
+
+var (
+	initialBaseFeeUint           = uint256.NewInt(params.InitialBaseFee)
+	baseFeeChangeDenominatorUint = uint256.NewInt(params.BaseFeeChangeDenominator)
+)
+
+// CalcBaseFee calculates the basefee of the header.
+func CalcBaseFeeUint(config *params.ChainConfig, parent *types.Header) *uint256.Int {
+	// If the current block is the first EIP-1559 block, return the InitialBaseFee.
+	if !config.IsLondon(parent.Number) {
+		return initialBaseFeeUint.Clone()
+	}
+
+	var (
+		parentGasTarget    = parent.GasLimit / params.ElasticityMultiplier
+		parentGasTargetBig = uint256.NewInt(parentGasTarget)
+	)
+
+	// If the parent gasUsed is the same as the target, the baseFee remains unchanged.
+	if parent.GasUsed == parentGasTarget {
+		return math.FromBig(parent.BaseFee)
+	}
+
+	if parent.GasUsed > parentGasTarget {
+		// If the parent block used more gas than its target, the baseFee should increase.
+		gasUsedDelta := uint256.NewInt(parent.GasUsed - parentGasTarget)
+
+		parentBaseFee := math.FromBig(parent.BaseFee)
+		x := gasUsedDelta.Mul(parentBaseFee, gasUsedDelta)
+		y := x.Div(x, parentGasTargetBig)
+		baseFeeDelta := math.BigMaxUint(
+			x.Div(y, baseFeeChangeDenominatorUint),
+			math.U1,
+		)
+
+		return x.Add(parentBaseFee, baseFeeDelta)
+	}
+
+	// Otherwise if the parent block used less gas than its target, the baseFee should decrease.
+	gasUsedDelta := uint256.NewInt(parentGasTarget - parent.GasUsed)
+	parentBaseFee := math.FromBig(parent.BaseFee)
+	x := gasUsedDelta.Mul(parentBaseFee, gasUsedDelta)
+	y := x.Div(x, parentGasTargetBig)
+	baseFeeDelta := x.Div(y, baseFeeChangeDenominatorUint)
+
+	return math.BigMaxUint(
+		x.Sub(parentBaseFee, baseFeeDelta),
+		math.U0.Clone(),
+	)
+}
diff --git a/consensus/misc/eip1559_test.go b/consensus/misc/eip1559_test.go
index 23cd9023de..1141c65011 100644
--- a/consensus/misc/eip1559_test.go
+++ b/consensus/misc/eip1559_test.go
@@ -20,6 +20,8 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
@@ -108,6 +110,8 @@ func TestBlockGasLimits(t *testing.T) {
 
 // TestCalcBaseFee assumes all blocks are 1559-blocks
 func TestCalcBaseFee(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		parentBaseFee   int64
 		parentGasLimit  uint64
@@ -130,3 +134,29 @@ func TestCalcBaseFee(t *testing.T) {
 		}
 	}
 }
+
+func TestCalcBaseFeeUint(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		parentBaseFee   int64
+		parentGasLimit  uint64
+		parentGasUsed   uint64
+		expectedBaseFee uint64
+	}{
+		{params.InitialBaseFee, 20000000, 10000000, params.InitialBaseFee}, // usage == target
+		{params.InitialBaseFee, 20000000, 9000000, 987500000},              // usage below target
+		{params.InitialBaseFee, 20000000, 11000000, 1012500000},            // usage above target
+	}
+	for i, test := range tests {
+		parent := &types.Header{
+			Number:   common.Big32,
+			GasLimit: test.parentGasLimit,
+			GasUsed:  test.parentGasUsed,
+			BaseFee:  big.NewInt(test.parentBaseFee),
+		}
+		if have, want := CalcBaseFeeUint(config(), parent), uint256.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
+			t.Errorf("test %d: have %d  want %d, ", i, have, want)
+		}
+	}
+}
diff --git a/core/tx_list.go b/core/tx_list.go
index 5e0bf75441..7188b2c422 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -19,7 +19,6 @@ package core
 import (
 	"container/heap"
 	"math"
-	"math/big"
 	"sort"
 	"sync"
 	"sync/atomic"
@@ -466,7 +465,7 @@ func (l *txList) LastElement() *types.Transaction {
 // then the heap is sorted based on the effective tip based on the given base fee.
 // If baseFee is nil then the sorting is based on gasFeeCap.
 type priceHeap struct {
-	baseFee *big.Int // heap should always be re-sorted after baseFee is changed
+	baseFee *uint256.Int // heap should always be re-sorted after baseFee is changed
 	list    []*types.Transaction
 }
 
@@ -487,14 +486,16 @@ func (h *priceHeap) Less(i, j int) bool {
 func (h *priceHeap) cmp(a, b *types.Transaction) int {
 	if h.baseFee != nil {
 		// Compare effective tips if baseFee is specified
-		if c := a.EffectiveGasTipCmp(b, h.baseFee); c != 0 {
+		if c := a.EffectiveGasTipTxUintCmp(b, h.baseFee); c != 0 {
 			return c
 		}
 	}
+
 	// Compare fee caps if baseFee is not specified or effective tips are equal
 	if c := a.GasFeeCapCmp(b); c != 0 {
 		return c
 	}
+
 	// Compare tips if effective tips and fee caps are equal
 	return a.GasTipCapCmp(b)
 }
@@ -674,7 +675,7 @@ func (l *txPricedList) Reheap() {
 
 // SetBaseFee updates the base fee and triggers a re-heap. Note that Removed is not
 // necessary to call right before SetBaseFee when processing a new block.
-func (l *txPricedList) SetBaseFee(baseFee *big.Int) {
+func (l *txPricedList) SetBaseFee(baseFee *uint256.Int) {
 	l.urgent.baseFee = baseFee
 	l.Reheap()
 }
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 62562b573d..e8041a2ed6 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -575,7 +575,7 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 // transactions and only return those whose **effective** tip is large enough in
 // the next pending execution environment.
 func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transactions {
-	pending := make(map[common.Address]types.Transactions)
+	pending := make(map[common.Address]types.Transactions, 10)
 
 	pool.pendingMu.RLock()
 	defer pool.pendingMu.RUnlock()
@@ -586,7 +586,7 @@ func (pool *TxPool) Pending(enforceTips bool) map[common.Address]types.Transacti
 		// If the miner requests tip enforcement, cap the lists now
 		if enforceTips && !pool.locals.contains(addr) {
 			for i, tx := range txs {
-				if tx.EffectiveGasTipIntCmp(pool.gasPrice, pool.priced.urgent.baseFee) < 0 {
+				if tx.EffectiveGasTipUintLt(pool.gasPriceUint, pool.priced.urgent.baseFee) {
 					txs = txs[:i]
 					break
 				}
@@ -1392,7 +1392,7 @@ func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirt
 		if reset.newHead != nil {
 			if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
 				// london fork enabled, reset given the base fee
-				pendingBaseFee := misc.CalcBaseFee(pool.chainconfig, reset.newHead)
+				pendingBaseFee := misc.CalcBaseFeeUint(pool.chainconfig, reset.newHead)
 				pool.priced.SetBaseFee(pendingBaseFee)
 			} else {
 				// london fork not enabled, reheap to "reset" the priced list
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 80d4ec6ff8..81a04d9d50 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2128,7 +2128,7 @@ func TestDualHeapEviction(t *testing.T) {
 
 	add(false)
 	for baseFee = 0; baseFee <= 1000; baseFee += 100 {
-		pool.priced.SetBaseFee(big.NewInt(int64(baseFee)))
+		pool.priced.SetBaseFee(uint256.NewInt(uint64(baseFee)))
 		add(true)
 		check(highCap, "fee cap")
 		add(false)
@@ -2719,6 +2719,89 @@ func BenchmarkPoolBatchInsert(b *testing.B) {
 	}
 }
 
+func BenchmarkPoolMining(b *testing.B) {
+	const format = "size %d"
+
+	cases := []struct {
+		name string
+		size int
+	}{
+		{size: 1},
+		{size: 5},
+		{size: 10},
+		//{size: 100},
+	}
+
+	for i := range cases {
+		cases[i].name = fmt.Sprintf(format, cases[i].size)
+	}
+
+	// Benchmark importing the transactions into the queue
+
+	for _, testCase := range cases {
+		singleCase := testCase
+
+		b.Run(singleCase.name, func(b *testing.B) {
+			// Generate a batch of transactions to enqueue into the pool
+			pendingAddedCh := make(chan struct{}, 1024)
+
+			pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
+			defer pool.Stop()
+
+			localKeyPub := localKey.PublicKey
+			account := crypto.PubkeyToAddress(localKeyPub)
+
+			balanceStr := "1_000_000_000"
+			balance, ok := big.NewInt(0).SetString(balanceStr, 0)
+			if !ok {
+				b.Fatal("incorrect initial balance", balanceStr)
+			}
+
+			testAddBalance(pool, account, balance)
+
+			signer := types.NewEIP155Signer(big.NewInt(1))
+			baseFee := uint256.NewInt(1)
+
+			const batchesSize = 100
+
+			batches := make([]types.Transactions, batchesSize)
+
+			for i := 0; i < batchesSize; i++ {
+				batches[i] = make(types.Transactions, singleCase.size)
+
+				for j := 0; j < singleCase.size; j++ {
+					batches[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, localKey)
+				}
+
+				for _, batch := range batches {
+					pool.AddRemotes(batch)
+				}
+			}
+
+			var promoted int
+
+			for range pendingAddedCh {
+				promoted++
+
+				if promoted >= batchesSize*singleCase.size/2 {
+					break
+				}
+			}
+
+			var total int
+
+			b.ResetTimer()
+			b.ReportAllocs()
+
+			for i := 0; i < b.N; i++ {
+				total += mining(pool, signer, baseFee)
+			}
+
+			b.StopTimer()
+		})
+	}
+}
+
 func BenchmarkInsertRemoteWithAllLocals(b *testing.B) {
 	// Allocate keys for testing
 	key, _ := crypto.GenerateKey()
@@ -3502,7 +3585,7 @@ func fillTransactions(ctx context.Context, pool *TxPool, locals []common.Address
 	signer := types.NewLondonSigner(big.NewInt(1))
 
 	// fake baseFee
-	baseFee := big.NewInt(1)
+	baseFee := uint256.NewInt(1)
 
 	blockGasLimit := gasLimit
 
@@ -3574,3 +3657,41 @@ func MakeWithPromoteTxCh(ch chan struct{}) func(*TxPool) {
 		pool.promoteTxCh = ch
 	}
 }
+
+func mining(pool *TxPool, signer types.Signer, baseFee *uint256.Int) int {
+	var (
+		localTxsCount  int
+		remoteTxsCount int
+		localTxs       = make(map[common.Address]types.Transactions)
+		remoteTxs      map[common.Address]types.Transactions
+		total          int
+	)
+
+	pending := pool.Pending(true)
+	remoteTxs = pending
+
+	for _, account := range pool.Locals() {
+		if txs := remoteTxs[account]; len(txs) > 0 {
+			delete(remoteTxs, account)
+
+			localTxs[account] = txs
+		}
+	}
+
+	localTxsCount = len(localTxs)
+	remoteTxsCount = len(remoteTxs)
+
+	if localTxsCount > 0 {
+		txs := types.NewTransactionsByPriceAndNonce(signer, localTxs, baseFee)
+
+		total += txs.GetTxs()
+	}
+
+	if remoteTxsCount > 0 {
+		txs := types.NewTransactionsByPriceAndNonce(signer, remoteTxs, baseFee)
+
+		total += txs.GetTxs()
+	}
+
+	return total
+}
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 0169536981..b9246911c0 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -394,6 +394,51 @@ func (tx *Transaction) EffectiveGasTipIntCmp(other *big.Int, baseFee *big.Int) i
 	return tx.EffectiveGasTipValue(baseFee).Cmp(other)
 }
 
+func (tx *Transaction) EffectiveGasTipUintCmp(other *uint256.Int, baseFee *uint256.Int) int {
+	if baseFee == nil {
+		return tx.GasTipCapUIntCmp(other)
+	}
+
+	return tx.EffectiveGasTipValueUint(baseFee).Cmp(other)
+}
+
+func (tx *Transaction) EffectiveGasTipUintLt(other *uint256.Int, baseFee *uint256.Int) bool {
+	if baseFee == nil {
+		return tx.GasTipCapUIntLt(other)
+	}
+
+	return tx.EffectiveGasTipValueUint(baseFee).Lt(other)
+}
+
+func (tx *Transaction) EffectiveGasTipTxUintCmp(other *Transaction, baseFee *uint256.Int) int {
+	if baseFee == nil {
+		return tx.GasTipCapCmp(other)
+		return tx.inner.gasTipCapU256().Cmp(other.inner.gasTipCapU256())
+	}
+
+	return tx.EffectiveGasTipValueUint(baseFee).Cmp(other.EffectiveGasTipValueUint(baseFee))
+}
+
+func (tx *Transaction) EffectiveGasTipValueUint(baseFee *uint256.Int) *uint256.Int {
+	effectiveTip, _ := tx.EffectiveGasTipUnit(baseFee)
+	return effectiveTip
+}
+
+func (tx *Transaction) EffectiveGasTipUnit(baseFee *uint256.Int) (*uint256.Int, error) {
+	if baseFee == nil {
+		return tx.GasFeeCapUint(), nil
+	}
+
+	var err error
+	gasFeeCap := tx.GasFeeCapUint()
+
+	if gasFeeCap.Lt(baseFee) {
+		err = ErrGasFeeCapTooLow
+	}
+
+	return math.BigMinUint256(tx.GasTipCapUint(), gasFeeCap.Sub(gasFeeCap, baseFee)), err
+}
+
 // Hash returns the transaction hash.
 func (tx *Transaction) Hash() common.Hash {
 	if hash := tx.hash.Load(); hash != nil {
@@ -487,14 +532,14 @@ func (s TxByNonce) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 // TxWithMinerFee wraps a transaction with its gas price or effective miner gasTipCap
 type TxWithMinerFee struct {
 	tx       *Transaction
-	minerFee *big.Int
+	minerFee *uint256.Int
 }
 
 // NewTxWithMinerFee creates a wrapped transaction, calculating the effective
 // miner gasTipCap if a base fee is provided.
 // Returns error in case of a negative effective miner gasTipCap.
-func NewTxWithMinerFee(tx *Transaction, baseFee *big.Int) (*TxWithMinerFee, error) {
-	minerFee, err := tx.EffectiveGasTip(baseFee)
+func NewTxWithMinerFee(tx *Transaction, baseFee *uint256.Int) (*TxWithMinerFee, error) {
+	minerFee, err := tx.EffectiveGasTipUnit(baseFee)
 	if err != nil {
 		return nil, err
 	}
@@ -539,7 +584,7 @@ type TransactionsByPriceAndNonce struct {
 	txs     map[common.Address]Transactions // Per account nonce-sorted list of transactions
 	heads   TxByPriceAndTime                // Next transaction for each unique account (price heap)
 	signer  Signer                          // Signer for the set of transactions
-	baseFee *big.Int                        // Current base fee
+	baseFee *uint256.Int                    // Current base fee
 }
 
 // NewTransactionsByPriceAndNonce creates a transaction set that can retrieve
@@ -547,6 +592,7 @@ type TransactionsByPriceAndNonce struct {
 //
 // Note, the input map is reowned so the caller should not interact any more with
 // if after providing it to the constructor.
+/*
 func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *big.Int) *TransactionsByPriceAndNonce {
 	// Initialize a price and received time based heap with the head transactions
 	heads := make(TxByPriceAndTime, 0, len(txs))
@@ -567,6 +613,35 @@ func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transa
 	}
 	heap.Init(&heads)
 
+	// Assemble and return the transaction set
+	return &TransactionsByPriceAndNonce{
+		txs:     txs,
+		heads:   heads,
+		signer:  signer,
+		baseFee: baseFee,
+	}
+}*/
+
+func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *uint256.Int) *TransactionsByPriceAndNonce {
+	// Initialize a price and received time based heap with the head transactions
+	heads := make(TxByPriceAndTime, 0, len(txs))
+	for from, accTxs := range txs {
+		if len(accTxs) == 0 {
+			continue
+		}
+
+		acc, _ := Sender(signer, accTxs[0])
+		wrapped, err := NewTxWithMinerFee(accTxs[0], baseFee)
+		// Remove transaction if sender doesn't match from, or if wrapping fails.
+		if acc != from || err != nil {
+			delete(txs, from)
+			continue
+		}
+		heads = append(heads, wrapped)
+		txs[from] = accTxs[1:]
+	}
+	heap.Init(&heads)
+
 	// Assemble and return the transaction set
 	return &TransactionsByPriceAndNonce{
 		txs:     txs,
diff --git a/miner/worker.go b/miner/worker.go
index 797e7ea980..3eb79514bf 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -31,6 +31,7 @@ import (
 	"go.opentelemetry.io/otel/trace"
 
 	"github.com/ethereum/go-ethereum/common"
+	cmath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/common/tracing"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc"
@@ -622,13 +623,17 @@ func (w *worker) mainLoop(ctx context.Context) {
 				if gp := w.current.gasPool; gp != nil && gp.Gas() < params.TxGas {
 					continue
 				}
+
 				txs := make(map[common.Address]types.Transactions)
+
 				for _, tx := range ev.Txs {
 					acc, _ := types.Sender(w.current.signer, tx)
 					txs[acc] = append(txs[acc], tx)
 				}
-				txset := types.NewTransactionsByPriceAndNonce(w.current.signer, txs, w.current.header.BaseFee)
+
+				txset := types.NewTransactionsByPriceAndNonce(w.current.signer, txs, cmath.FromBig(w.current.header.BaseFee))
 				tcount := w.current.tcount
+
 				w.commitTransactions(w.current, txset, nil)
 
 				// Only update the snapshot if any new transactions were added
@@ -1077,7 +1082,7 @@ func (w *worker) prepareWork(genParams *generateParams) (*environment, error) {
 	}
 	// Set baseFee and GasLimit if we are on an EIP-1559 chain
 	if w.chainConfig.IsLondon(header.Number) {
-		header.BaseFee = misc.CalcBaseFee(w.chainConfig, parent.Header())
+		header.BaseFee = misc.CalcBaseFeeUint(w.chainConfig, parent.Header()).ToBig()
 		if !w.chainConfig.IsLondon(parent.Number()) {
 			parentGasLimit := parent.GasLimit() * params.ElasticityMultiplier
 			header.GasLimit = core.CalcGasLimit(parentGasLimit, w.config.GasCeil)
@@ -1165,7 +1170,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		var txs *types.TransactionsByPriceAndNonce
 
 		tracing.Exec(ctx, "worker.LocalTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) {
-			txs = types.NewTransactionsByPriceAndNonce(env.signer, localTxs, env.header.BaseFee)
+			txs = types.NewTransactionsByPriceAndNonce(env.signer, localTxs, cmath.FromBig(env.header.BaseFee))
 
 			tracing.SetAttributes(
 				span,
@@ -1188,7 +1193,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		var txs *types.TransactionsByPriceAndNonce
 
 		tracing.Exec(ctx, "worker.RemoteTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) {
-			txs = types.NewTransactionsByPriceAndNonce(env.signer, remoteTxs, env.header.BaseFee)
+			txs = types.NewTransactionsByPriceAndNonce(env.signer, remoteTxs, cmath.FromBig(env.header.BaseFee))
 
 			tracing.SetAttributes(
 				span,

From 29277ee5118b0bd840aff23987e15e31c8999dc1 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 22:59:34 +0400
Subject: [PATCH 51/96] fix copy

---
 core/tx_pool_test.go           |  2 +-
 core/types/transaction.go      | 22 +++++++++++++++++++++-
 core/types/transaction_test.go | 28 ++++++++++++++++++++++++----
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 81a04d9d50..044862b9e5 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2729,7 +2729,7 @@ func BenchmarkPoolMining(b *testing.B) {
 		{size: 1},
 		{size: 5},
 		{size: 10},
-		//{size: 100},
+		{size: 20},
 	}
 
 	for i := range cases {
diff --git a/core/types/transaction.go b/core/types/transaction.go
index b9246911c0..f1e9b27b86 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -436,7 +436,27 @@ func (tx *Transaction) EffectiveGasTipUnit(baseFee *uint256.Int) (*uint256.Int,
 		err = ErrGasFeeCapTooLow
 	}
 
-	return math.BigMinUint256(tx.GasTipCapUint(), gasFeeCap.Sub(gasFeeCap, baseFee)), err
+	gasTipCapUint := tx.GasTipCapUint()
+
+	if gasFeeCap.Lt(gasTipCapUint) {
+		return gasFeeCap, err
+	}
+
+	if gasFeeCap.Lt(gasTipCapUint) && baseFee.IsZero() {
+		return gasFeeCap, err
+	}
+
+	gasFeeCap.Sub(gasFeeCap, baseFee)
+	if gasFeeCap.Gt(gasTipCapUint) || gasFeeCap.Eq(gasTipCapUint) {
+		gasFeeCap.Add(gasFeeCap, baseFee)
+		return gasTipCapUint, err
+	}
+
+	gasFeeCapWithoudBaseFee := gasFeeCap.Clone()
+
+	gasFeeCap.Add(gasFeeCap, baseFee)
+
+	return gasFeeCapWithoudBaseFee, err
 }
 
 // Hash returns the transaction hash.
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index a4755675cd..39fad67223 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -27,7 +27,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/holiman/uint256"
+
 	"github.com/ethereum/go-ethereum/common"
+	cmath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
 )
@@ -272,7 +275,7 @@ func TestTransactionPriceNonceSort1559(t *testing.T) {
 // Tests that transactions can be correctly sorted according to their price in
 // decreasing order, but at the same time with increasing nonces when issued by
 // the same account.
-func testTransactionPriceNonceSort(t *testing.T, baseFee *big.Int) {
+func testTransactionPriceNonceSort(t *testing.T, baseFeeBig *big.Int) {
 	// Generate a batch of accounts to start with
 	keys := make([]*ecdsa.PrivateKey, 25)
 	for i := 0; i < len(keys); i++ {
@@ -280,6 +283,11 @@ func testTransactionPriceNonceSort(t *testing.T, baseFee *big.Int) {
 	}
 	signer := LatestSignerForChainID(common.Big1)
 
+	var baseFee *uint256.Int
+	if baseFeeBig != nil {
+		baseFee = cmath.FromBig(baseFeeBig)
+	}
+
 	// Generate a batch of transactions with overlapping values, but shifted nonces
 	groups := map[common.Address]Transactions{}
 	expectedCount := 0
@@ -308,7 +316,7 @@ func testTransactionPriceNonceSort(t *testing.T, baseFee *big.Int) {
 					GasTipCap: big.NewInt(int64(rand.Intn(gasFeeCap + 1))),
 					Data:      nil,
 				})
-				if count == 25 && int64(gasFeeCap) < baseFee.Int64() {
+				if count == 25 && uint64(gasFeeCap) < baseFee.Uint64() {
 					count = i
 				}
 			}
@@ -345,8 +353,20 @@ func testTransactionPriceNonceSort(t *testing.T, baseFee *big.Int) {
 		if i+1 < len(txs) {
 			next := txs[i+1]
 			fromNext, _ := Sender(signer, next)
-			tip, err := txi.EffectiveGasTip(baseFee)
-			nextTip, nextErr := next.EffectiveGasTip(baseFee)
+			tip, err := txi.EffectiveGasTipUnit(baseFee)
+			nextTip, nextErr := next.EffectiveGasTipUnit(baseFee)
+
+			tipBig, _ := txi.EffectiveGasTip(baseFeeBig)
+			nextTipBig, _ := next.EffectiveGasTip(baseFeeBig)
+
+			if tip.Cmp(cmath.FromBig(tipBig)) != 0 {
+				t.Fatalf("EffectiveGasTip incorrect. uint256 %q, big.Int %q", tip.String(), tipBig.String())
+			}
+
+			if nextTip.Cmp(cmath.FromBig(nextTipBig)) != 0 {
+				t.Fatalf("EffectiveGasTip next incorrect. uint256 %q, big.Int %q", nextTip.String(), nextTipBig.String())
+			}
+
 			if err != nil || nextErr != nil {
 				t.Errorf("error calculating effective tip")
 			}

From f1e3c92bd4161de0f7bf7dc68919b6ad9c237cdb Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 23 Oct 2022 23:03:10 +0400
Subject: [PATCH 52/96] linters

---
 core/types/transaction.go      | 8 +++++++-
 core/types/transaction_test.go | 4 ++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/core/types/transaction.go b/core/types/transaction.go
index f1e9b27b86..8eccfbf691 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -412,7 +412,6 @@ func (tx *Transaction) EffectiveGasTipUintLt(other *uint256.Int, baseFee *uint25
 
 func (tx *Transaction) EffectiveGasTipTxUintCmp(other *Transaction, baseFee *uint256.Int) int {
 	if baseFee == nil {
-		return tx.GasTipCapCmp(other)
 		return tx.inner.gasTipCapU256().Cmp(other.inner.gasTipCapU256())
 	}
 
@@ -430,6 +429,7 @@ func (tx *Transaction) EffectiveGasTipUnit(baseFee *uint256.Int) (*uint256.Int,
 	}
 
 	var err error
+
 	gasFeeCap := tx.GasFeeCapUint()
 
 	if gasFeeCap.Lt(baseFee) {
@@ -447,8 +447,10 @@ func (tx *Transaction) EffectiveGasTipUnit(baseFee *uint256.Int) (*uint256.Int,
 	}
 
 	gasFeeCap.Sub(gasFeeCap, baseFee)
+
 	if gasFeeCap.Gt(gasTipCapUint) || gasFeeCap.Eq(gasTipCapUint) {
 		gasFeeCap.Add(gasFeeCap, baseFee)
+
 		return gasTipCapUint, err
 	}
 
@@ -645,6 +647,7 @@ func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transa
 func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions, baseFee *uint256.Int) *TransactionsByPriceAndNonce {
 	// Initialize a price and received time based heap with the head transactions
 	heads := make(TxByPriceAndTime, 0, len(txs))
+
 	for from, accTxs := range txs {
 		if len(accTxs) == 0 {
 			continue
@@ -652,14 +655,17 @@ func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transa
 
 		acc, _ := Sender(signer, accTxs[0])
 		wrapped, err := NewTxWithMinerFee(accTxs[0], baseFee)
+
 		// Remove transaction if sender doesn't match from, or if wrapping fails.
 		if acc != from || err != nil {
 			delete(txs, from)
 			continue
 		}
+
 		heads = append(heads, wrapped)
 		txs[from] = accTxs[1:]
 	}
+
 	heap.Init(&heads)
 
 	// Assemble and return the transaction set
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index 39fad67223..9884185260 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -275,12 +275,15 @@ func TestTransactionPriceNonceSort1559(t *testing.T) {
 // Tests that transactions can be correctly sorted according to their price in
 // decreasing order, but at the same time with increasing nonces when issued by
 // the same account.
+//
+//nolint:gocognit,thelper
 func testTransactionPriceNonceSort(t *testing.T, baseFeeBig *big.Int) {
 	// Generate a batch of accounts to start with
 	keys := make([]*ecdsa.PrivateKey, 25)
 	for i := 0; i < len(keys); i++ {
 		keys[i], _ = crypto.GenerateKey()
 	}
+
 	signer := LatestSignerForChainID(common.Big1)
 
 	var baseFee *uint256.Int
@@ -349,6 +352,7 @@ func testTransactionPriceNonceSort(t *testing.T, baseFeeBig *big.Int) {
 				t.Errorf("invalid nonce ordering: tx #%d (A=%x N=%v) < tx #%d (A=%x N=%v)", i, fromi[:4], txi.Nonce(), i+j, fromj[:4], txj.Nonce())
 			}
 		}
+
 		// If the next tx has different from account, the price must be lower than the current one
 		if i+1 < len(txs) {
 			next := txs[i+1]

From 9832c446738802df182120b574e0acde2810e154 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 27 Oct 2022 11:29:21 +0400
Subject: [PATCH 53/96] txpool tracing

---
 core/tx_pool.go | 231 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 155 insertions(+), 76 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index e8041a2ed6..6d18ccbf43 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -17,6 +17,7 @@
 package core
 
 import (
+	"context"
 	"errors"
 	"math"
 	"math/big"
@@ -26,8 +27,11 @@ import (
 	"time"
 
 	"github.com/holiman/uint256"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/tracing"
 	"github.com/ethereum/go-ethereum/consensus/misc"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -1292,8 +1296,10 @@ func (pool *TxPool) scheduleReorgLoop() {
 	for {
 		// Launch next background reorg if needed
 		if curDone == nil && launchNextRun {
+			ctx := context.Background()
+
 			// Run the background reorg and announcements
-			go pool.runReorg(nextDone, reset, dirtyAccounts, queuedEvents)
+			go pool.runReorg(ctx, nextDone, reset, dirtyAccounts, queuedEvents)
 
 			// Prepare everything for the next round of reorg
 			curDone, nextDone = nextDone, make(chan struct{})
@@ -1348,95 +1354,168 @@ func (pool *TxPool) scheduleReorgLoop() {
 }
 
 // runReorg runs reset and promoteExecutables on behalf of scheduleReorgLoop.
-func (pool *TxPool) runReorg(done chan struct{}, reset *txpoolResetRequest, dirtyAccounts *accountSet, events map[common.Address]*txSortedMap) {
-	defer func(t0 time.Time) {
-		reorgDurationTimer.Update(time.Since(t0))
-	}(time.Now())
+func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txpoolResetRequest, dirtyAccounts *accountSet, events map[common.Address]*txSortedMap) {
+	tracing.Exec(ctx, "txpool-reorg", func(ctx context.Context, span trace.Span) {
+		defer func(t0 time.Time) {
+			reorgDurationTimer.Update(time.Since(t0))
+		}(time.Now())
+
+		defer close(done)
+
+		var promoteAddrs []common.Address
+
+		tracing.ElapsedTime(ctx, span, "dirty accounts flattening", func(_ context.Context, innerSpan trace.Span) {
+			if dirtyAccounts != nil && reset == nil {
+				// Only dirty accounts need to be promoted, unless we're resetting.
+				// For resets, all addresses in the tx queue will be promoted and
+				// the flatten operation can be avoided.
+				promoteAddrs = dirtyAccounts.flatten()
+			}
 
-	defer close(done)
+			tracing.SetAttributes(
+				innerSpan,
+				attribute.Int("promoteAddresses-flatten", len(promoteAddrs)),
+			)
+		})
 
-	var promoteAddrs []common.Address
-	if dirtyAccounts != nil && reset == nil {
-		// Only dirty accounts need to be promoted, unless we're resetting.
-		// For resets, all addresses in the tx queue will be promoted and
-		// the flatten operation can be avoided.
-		promoteAddrs = dirtyAccounts.flatten()
-	}
-	pool.mu.Lock()
-	if reset != nil {
-		// Reset from the old head to the new, rescheduling any reorged transactions
-		pool.reset(reset.oldHead, reset.newHead)
-
-		// Nonces were reset, discard any events that became stale
-		for addr := range events {
-			events[addr].Forward(pool.pendingNonces.get(addr))
-			if events[addr].Len() == 0 {
-				delete(events, addr)
-			}
-		}
-		// Reset needs promote for all addresses
-		promoteAddrs = make([]common.Address, 0, len(pool.queue))
-		for addr := range pool.queue {
-			promoteAddrs = append(promoteAddrs, addr)
-		}
-	}
-	// Check for pending transactions for every account that sent new ones
-	promoted := pool.promoteExecutables(promoteAddrs)
+		tracing.ElapsedTime(ctx, span, "obtaining pool.WMutex", func(_ context.Context, _ trace.Span) {
+			pool.mu.Lock()
+		})
 
-	// If a new block appeared, validate the pool of pending transactions. This will
-	// remove any transaction that has been included in the block or was invalidated
-	// because of another transaction (e.g. higher gas price).
+		if reset != nil {
+			tracing.ElapsedTime(ctx, span, "reset-head reorg", func(_ context.Context, innerSpan trace.Span) {
 
-	if reset != nil {
-		pool.demoteUnexecutables()
-		if reset.newHead != nil {
-			if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
-				// london fork enabled, reset given the base fee
-				pendingBaseFee := misc.CalcBaseFeeUint(pool.chainconfig, reset.newHead)
-				pool.priced.SetBaseFee(pendingBaseFee)
-			} else {
-				// london fork not enabled, reheap to "reset" the priced list
-				pool.priced.Reheap()
-			}
-		}
-		// Update all accounts to the latest known pending nonce
-		nonces := make(map[common.Address]uint64, len(pool.pending))
+				// Reset from the old head to the new, rescheduling any reorged transactions
+				tracing.ElapsedTime(ctx, span, "reset-head-itself reorg", func(_ context.Context, innerSpan trace.Span) {
+					pool.reset(reset.oldHead, reset.newHead)
+				})
 
-		pool.pendingMu.RLock()
-		for addr, list := range pool.pending {
-			highestPending := list.LastElement()
-			nonces[addr] = highestPending.Nonce() + 1
+				tracing.SetAttributes(
+					innerSpan,
+					attribute.Int("events-reset-head", len(events)),
+				)
+
+				// Nonces were reset, discard any events that became stale
+				for addr := range events {
+					events[addr].Forward(pool.pendingNonces.get(addr))
+
+					if events[addr].Len() == 0 {
+						delete(events, addr)
+					}
+				}
+
+				// Reset needs promote for all addresses
+				promoteAddrs = make([]common.Address, 0, len(pool.queue))
+				for addr := range pool.queue {
+					promoteAddrs = append(promoteAddrs, addr)
+				}
+
+				tracing.SetAttributes(
+					innerSpan,
+					attribute.Int("promoteAddresses-reset-head", len(promoteAddrs)),
+				)
+			})
 		}
 
-		pool.pendingMu.RUnlock()
+		// Check for pending transactions for every account that sent new ones
+		var promoted []*types.Transaction
 
-		pool.pendingNonces.setAll(nonces)
-	}
+		tracing.ElapsedTime(ctx, span, "promoteExecutables", func(_ context.Context, _ trace.Span) {
+			promoted = pool.promoteExecutables(promoteAddrs)
+		})
 
-	// Ensure pool.queue and pool.pending sizes stay within the configured limits.
-	pool.truncatePending()
-	pool.truncateQueue()
+		tracing.SetAttributes(
+			span,
+			attribute.Int("promoteAddresses-reset-head", len(promoteAddrs)),
+			attribute.Int("all", pool.all.Count()),
+			attribute.Int("pending", len(pool.pending)),
+			attribute.Int("queue", len(pool.queue)),
+		)
 
-	dropBetweenReorgHistogram.Update(int64(pool.changesSinceReorg))
-	pool.changesSinceReorg = 0 // Reset change counter
-	pool.mu.Unlock()
+		// If a new block appeared, validate the pool of pending transactions. This will
+		// remove any transaction that has been included in the block or was invalidated
+		// because of another transaction (e.g. higher gas price).
+
+		if reset != nil {
+			tracing.ElapsedTime(ctx, span, "new block", func(_ context.Context, innerSpan trace.Span) {
+
+				tracing.ElapsedTime(ctx, innerSpan, "demoteUnexecutables", func(_ context.Context, _ trace.Span) {
+					pool.demoteUnexecutables()
+				})
+
+				if reset.newHead != nil {
+					if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
+						// london fork enabled, reset given the base fee
+						pendingBaseFee := misc.CalcBaseFeeUint(pool.chainconfig, reset.newHead)
+						pool.priced.SetBaseFee(pendingBaseFee)
+					} else {
+						// london fork not enabled, reheap to "reset" the priced list
+						pool.priced.Reheap()
+					}
+				}
+
+				// Update all accounts to the latest known pending nonce
+				nonces := make(map[common.Address]uint64, len(pool.pending))
+
+				tracing.ElapsedTime(ctx, innerSpan, "obtaining pendingMu.RMutex", func(_ context.Context, innerSpan trace.Span) {
+					pool.pendingMu.RLock()
+				})
+
+				var highestPending *types.Transaction
+
+				for addr, list := range pool.pending {
+					highestPending = list.LastElement()
+					nonces[addr] = highestPending.Nonce() + 1
+				}
 
-	// Notify subsystems for newly added transactions
-	for _, tx := range promoted {
-		addr, _ := types.Sender(pool.signer, tx)
-		if _, ok := events[addr]; !ok {
-			events[addr] = newTxSortedMap()
+				pool.pendingMu.RUnlock()
+
+				tracing.ElapsedTime(ctx, innerSpan, "reset nonces", func(_ context.Context, _ trace.Span) {
+					pool.pendingNonces.setAll(nonces)
+				})
+			})
 		}
-		events[addr].Put(tx)
-	}
 
-	if len(events) > 0 {
-		var txs []*types.Transaction
-		for _, set := range events {
-			txs = append(txs, set.Flatten()...)
+		// Ensure pool.queue and pool.pending sizes stay within the configured limits.
+		tracing.ElapsedTime(ctx, span, "truncatePending", func(_ context.Context, _ trace.Span) {
+			pool.truncatePending()
+		})
+
+		tracing.ElapsedTime(ctx, span, "truncateQueue", func(_ context.Context, _ trace.Span) {
+			pool.truncateQueue()
+		})
+
+		dropBetweenReorgHistogram.Update(int64(pool.changesSinceReorg))
+		pool.changesSinceReorg = 0 // Reset change counter
+
+		pool.mu.Unlock()
+
+		// Notify subsystems for newly added transactions
+		tracing.ElapsedTime(ctx, span, "notify about new transactions", func(_ context.Context, _ trace.Span) {
+			for _, tx := range promoted {
+				addr, _ := types.Sender(pool.signer, tx)
+
+				if _, ok := events[addr]; !ok {
+					events[addr] = newTxSortedMap()
+				}
+
+				events[addr].Put(tx)
+			}
+		})
+
+		if len(events) > 0 {
+			tracing.ElapsedTime(ctx, span, "txFeed", func(_ context.Context, _ trace.Span) {
+				var txs []*types.Transaction
+
+				for _, set := range events {
+					txs = append(txs, set.Flatten()...)
+				}
+
+				pool.txFeed.Send(NewTxsEvent{txs})
+			})
 		}
-		pool.txFeed.Send(NewTxsEvent{txs})
-	}
+
+	})
 }
 
 // reset retrieves the current state of the blockchain and ensures the content

From 758eb4ffa1a5032fde50bac249f8a1d9c3c26f8b Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 27 Oct 2022 11:34:12 +0400
Subject: [PATCH 54/96] linters

---
 core/tx_pool.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 6d18ccbf43..6d52dabbee 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -1354,6 +1354,7 @@ func (pool *TxPool) scheduleReorgLoop() {
 }
 
 // runReorg runs reset and promoteExecutables on behalf of scheduleReorgLoop.
+//nolint:gocognit
 func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txpoolResetRequest, dirtyAccounts *accountSet, events map[common.Address]*txSortedMap) {
 	tracing.Exec(ctx, "txpool-reorg", func(ctx context.Context, span trace.Span) {
 		defer func(t0 time.Time) {
@@ -1707,6 +1708,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Trans
 			delete(pool.beats, addr)
 		}
 	}
+
 	return promoted
 }
 

From 729355138cb487d3e0b5459a6dedd75c13a8812e Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 27 Oct 2022 18:28:19 +0400
Subject: [PATCH 55/96] fix tracing

---
 common/tracing/context.go |  8 +++++++-
 consensus/bor/bor.go      |  8 ++++----
 core/tx_pool.go           |  6 +++---
 miner/worker.go           | 14 +++++++-------
 4 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/common/tracing/context.go b/common/tracing/context.go
index 510e45d775..054313a502 100644
--- a/common/tracing/context.go
+++ b/common/tracing/context.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"time"
 
+	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/trace"
 )
@@ -51,11 +52,16 @@ func Trace(ctx context.Context, spanName string) (context.Context, trace.Span) {
 	return tr.Start(ctx, spanName)
 }
 
-func Exec(ctx context.Context, spanName string, opts ...Option) {
+func Exec(ctx context.Context, instrumentationName, spanName string, opts ...Option) {
 	var span trace.Span
 
 	tr := FromContext(ctx)
 
+	if tr == nil && len(instrumentationName) != 0 {
+		tr = otel.GetTracerProvider().Tracer(instrumentationName)
+		ctx = WithTracer(ctx, tr)
+	}
+
 	if tr != nil {
 		ctx, span = tr.Start(ctx, spanName)
 	}
diff --git a/consensus/bor/bor.go b/consensus/bor/bor.go
index dee3998703..890b9a18e8 100644
--- a/consensus/bor/bor.go
+++ b/consensus/bor/bor.go
@@ -820,7 +820,7 @@ func (c *Bor) FinalizeAndAssemble(ctx context.Context, chain consensus.ChainHead
 	if IsSprintStart(headerNumber, c.config.Sprint) {
 		cx := statefull.ChainContext{Chain: chain, Bor: c}
 
-		tracing.Exec(finalizeCtx, "bor.checkAndCommitSpan", func(ctx context.Context, span trace.Span) {
+		tracing.Exec(finalizeCtx, "", "bor.checkAndCommitSpan", func(ctx context.Context, span trace.Span) {
 			// check and commit span
 			err = c.checkAndCommitSpan(finalizeCtx, state, header, cx)
 		})
@@ -831,7 +831,7 @@ func (c *Bor) FinalizeAndAssemble(ctx context.Context, chain consensus.ChainHead
 		}
 
 		if c.HeimdallClient != nil {
-			tracing.Exec(finalizeCtx, "bor.checkAndCommitSpan", func(ctx context.Context, span trace.Span) {
+			tracing.Exec(finalizeCtx, "", "bor.checkAndCommitSpan", func(ctx context.Context, span trace.Span) {
 				// commit states
 				stateSyncData, err = c.CommitStates(finalizeCtx, state, header, cx)
 			})
@@ -843,7 +843,7 @@ func (c *Bor) FinalizeAndAssemble(ctx context.Context, chain consensus.ChainHead
 		}
 	}
 
-	tracing.Exec(finalizeCtx, "bor.changeContractCodeIfNeeded", func(ctx context.Context, span trace.Span) {
+	tracing.Exec(finalizeCtx, "", "bor.changeContractCodeIfNeeded", func(ctx context.Context, span trace.Span) {
 		err = c.changeContractCodeIfNeeded(headerNumber, state)
 	})
 
@@ -853,7 +853,7 @@ func (c *Bor) FinalizeAndAssemble(ctx context.Context, chain consensus.ChainHead
 	}
 
 	// No block rewards in PoA, so the state remains as it is
-	tracing.Exec(finalizeCtx, "bor.IntermediateRoot", func(ctx context.Context, span trace.Span) {
+	tracing.Exec(finalizeCtx, "", "bor.IntermediateRoot", func(ctx context.Context, span trace.Span) {
 		header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
 	})
 
diff --git a/core/tx_pool.go b/core/tx_pool.go
index cc16c6c18c..2a567f291b 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -581,7 +581,7 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Address]types.Transactions {
 	pending := make(map[common.Address]types.Transactions, 10)
 
-	tracing.Exec(ctx, "txpool.Pending()", func(ctx context.Context, span trace.Span) {
+	tracing.Exec(ctx, "TxpoolPending", "txpool.Pending()", func(ctx context.Context, span trace.Span) {
 		tracing.ElapsedTime(ctx, span, "txpool.Pending.RLock()", func(ctx context.Context, s trace.Span) {
 			pool.pendingMu.RLock()
 		})
@@ -1373,7 +1373,7 @@ func (pool *TxPool) scheduleReorgLoop() {
 //
 //nolint:gocognit
 func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txpoolResetRequest, dirtyAccounts *accountSet, events map[common.Address]*txSortedMap) {
-	tracing.Exec(ctx, "txpool-reorg", func(ctx context.Context, span trace.Span) {
+	tracing.Exec(ctx, "TxPoolReorg", "txpool-reorg", func(ctx context.Context, span trace.Span) {
 		defer func(t0 time.Time) {
 			reorgDurationTimer.Update(time.Since(t0))
 		}(time.Now())
@@ -1404,7 +1404,7 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 			tracing.ElapsedTime(ctx, span, "reset-head reorg", func(_ context.Context, innerSpan trace.Span) {
 
 				// Reset from the old head to the new, rescheduling any reorged transactions
-				tracing.ElapsedTime(ctx, span, "reset-head-itself reorg", func(_ context.Context, innerSpan trace.Span) {
+				tracing.ElapsedTime(ctx, innerSpan, "reset-head-itself reorg", func(_ context.Context, innerSpan trace.Span) {
 					pool.reset(reset.oldHead, reset.newHead)
 				})
 
diff --git a/miner/worker.go b/miner/worker.go
index add26d104d..66b572f5a6 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -771,7 +771,7 @@ func (w *worker) resultLoop() {
 				err      error
 			)
 
-			tracing.Exec(task.ctx, "resultLoop", func(ctx context.Context, span trace.Span) {
+			tracing.Exec(task.ctx, "", "resultLoop", func(ctx context.Context, span trace.Span) {
 				for i, taskReceipt := range task.receipts {
 					receipt := new(types.Receipt)
 					receipts[i] = receipt
@@ -1273,7 +1273,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		}
 	}(env.header.Number.Uint64())
 
-	tracing.Exec(ctx, "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
+	tracing.Exec(ctx, "", "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 
 		prePendingTime := time.Now()
 
@@ -1312,7 +1312,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 	if localTxsCount > 0 {
 		var txs *types.TransactionsByPriceAndNonce
 
-		tracing.Exec(ctx, "worker.LocalTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) {
+		tracing.Exec(ctx, "", "worker.LocalTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) {
 			txs = types.NewTransactionsByPriceAndNonce(env.signer, localTxs, cmath.FromBig(env.header.BaseFee))
 
 			tracing.SetAttributes(
@@ -1321,7 +1321,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			)
 		})
 
-		tracing.Exec(ctx, "worker.LocalCommitTransactions", func(ctx context.Context, span trace.Span) {
+		tracing.Exec(ctx, "", "worker.LocalCommitTransactions", func(ctx context.Context, span trace.Span) {
 			committed = w.commitTransactions(env, txs, interrupt)
 		})
 
@@ -1335,7 +1335,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 	if remoteTxsCount > 0 {
 		var txs *types.TransactionsByPriceAndNonce
 
-		tracing.Exec(ctx, "worker.RemoteTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) {
+		tracing.Exec(ctx, "", "worker.RemoteTransactionsByPriceAndNonce", func(ctx context.Context, span trace.Span) {
 			txs = types.NewTransactionsByPriceAndNonce(env.signer, remoteTxs, cmath.FromBig(env.header.BaseFee))
 
 			tracing.SetAttributes(
@@ -1344,7 +1344,7 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 			)
 		})
 
-		tracing.Exec(ctx, "worker.RemoteCommitTransactions", func(ctx context.Context, span trace.Span) {
+		tracing.Exec(ctx, "", "worker.RemoteCommitTransactions", func(ctx context.Context, span trace.Span) {
 			committed = w.commitTransactions(env, txs, interrupt)
 		})
 
@@ -1385,7 +1385,7 @@ func (w *worker) commitWork(ctx context.Context, interrupt *int32, noempty bool,
 		err  error
 	)
 
-	tracing.Exec(ctx, "worker.prepareWork", func(ctx context.Context, span trace.Span) {
+	tracing.Exec(ctx, "", "worker.prepareWork", func(ctx context.Context, span trace.Span) {
 		// Set the coinbase if the worker is running or it's required
 		var coinbase common.Address
 		if w.isRunning() {

From 25f172a0d57651421a5fe4e324de055e30e4f74a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 27 Oct 2022 19:32:48 +0400
Subject: [PATCH 56/96] duration in mcs

---
 common/tracing/context.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/tracing/context.go b/common/tracing/context.go
index 054313a502..c3c6342502 100644
--- a/common/tracing/context.go
+++ b/common/tracing/context.go
@@ -91,7 +91,7 @@ func ElapsedTime(ctx context.Context, span trace.Span, msg string, fn func(conte
 	fn(ctx, span)
 
 	if span != nil {
-		span.SetAttributes(attribute.Int(msg, int(time.Since(now).Milliseconds())))
+		span.SetAttributes(attribute.Int(msg, int(time.Since(now).Microseconds())))
 	}
 }
 

From a1b1295432c547d1fd21c5994ffe791438102eae Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 27 Oct 2022 20:43:43 +0400
Subject: [PATCH 57/96] locks

---
 core/tx_pool.go | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 2a567f291b..41e5829ea3 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -588,8 +588,9 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 
 		defer pool.pendingMu.RUnlock()
 
-		accounts := len(pool.pending)
-		var txCount int
+		pendingAccounts := len(pool.pending)
+
+		var pendingTxs int
 
 		tracing.ElapsedTime(ctx, span, "Loop", func(ctx context.Context, s trace.Span) {
 			for addr, list := range pool.pending {
@@ -607,13 +608,13 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 
 				if len(txs) > 0 {
 					pending[addr] = txs
-					txCount += len(txs)
+					pendingTxs += len(txs)
 				}
 			}
 
 			tracing.SetAttributes(span,
-				attribute.Int("txCount", txCount),
-				attribute.Int("accounts", accounts),
+				attribute.Int("pending-transactions", pendingTxs),
+				attribute.Int("pending-accounts", pendingAccounts),
 			)
 		})
 	})
@@ -1758,11 +1759,16 @@ func (pool *TxPool) truncatePending() {
 		// Only evict transactions from high rollers
 		listLen = len(list.txs.items)
 
+		pool.pendingMu.RUnlock()
+
 		pool.locals.m.RLock()
 
 		if uint64(listLen) > pool.config.AccountSlots {
 			if _, ok = pool.locals.accounts[addr]; ok {
 				pool.locals.m.RUnlock()
+
+				pool.pendingMu.RLock()
+
 				continue
 			}
 
@@ -1772,7 +1778,10 @@ func (pool *TxPool) truncatePending() {
 		}
 
 		pool.locals.m.RUnlock()
+
+		pool.pendingMu.RLock()
 	}
+
 	pool.pendingMu.RUnlock()
 
 	// Gradually drop transactions from offenders
@@ -1977,8 +1986,7 @@ func (pool *TxPool) demoteUnexecutables() {
 	)
 
 	// Iterate over all accounts and demote any non-executable transactions
-	pool.pendingMu.Lock()
-	defer pool.pendingMu.Unlock()
+	pool.pendingMu.RLock()
 
 	for addr, list := range pool.pending {
 		nonce := pool.currentState.GetNonce(addr)
@@ -2042,10 +2050,18 @@ func (pool *TxPool) demoteUnexecutables() {
 		}
 		// Delete the entire pending entry if it became empty.
 		if list.Empty() {
+			pool.pendingMu.RUnlock()
+			pool.pendingMu.Lock()
+
 			pool.pendingCount -= pool.pending[addr].Len()
 			delete(pool.pending, addr)
+
+			pool.pendingMu.Unlock()
+			pool.pendingMu.RLock()
 		}
 	}
+
+	pool.pendingMu.RUnlock()
 }
 
 // addressByHeartbeat is an account address tagged with its last activity timestamp.

From 3aa7b0dd82bcc281a43de5ea27b29f47fcd47cff Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Fri, 28 Oct 2022 18:32:55 +0400
Subject: [PATCH 58/96] metrics

---
 core/tx_list.go | 85 ++++++++++++++++++++++++++++++++++++++-----------
 core/tx_pool.go | 72 ++++++++++++++++++++++-------------------
 2 files changed, 106 insertions(+), 51 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 7188b2c422..858adb9d9e 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -56,15 +56,19 @@ func (h *nonceHeap) Pop() interface{} {
 type txSortedMap struct {
 	items map[uint64]*types.Transaction // Hash map storing the transaction data
 	index *nonceHeap                    // Heap of nonces of all the stored transactions (non-strict mode)
-	cache types.Transactions            // Cache of the transactions already sorted
 	m     sync.RWMutex
+
+	cache     types.Transactions // Cache of the transactions already sorted
+	isEmpty   bool
+	cacheOnce sync.Once
 }
 
 // newTxSortedMap creates a new nonce-sorted transaction map.
 func newTxSortedMap() *txSortedMap {
 	return &txSortedMap{
-		items: make(map[uint64]*types.Transaction),
-		index: new(nonceHeap),
+		items:   make(map[uint64]*types.Transaction),
+		index:   new(nonceHeap),
+		isEmpty: true,
 	}
 }
 
@@ -87,7 +91,10 @@ func (m *txSortedMap) Put(tx *types.Transaction) {
 		heap.Push(m.index, nonce)
 	}
 
-	m.items[nonce], m.cache = tx, nil
+	m.items[nonce] = tx
+	m.cache = nil
+	m.isEmpty = true
+	m.cacheOnce = sync.Once{}
 }
 
 // Forward removes all transactions from the map with a nonce lower than the
@@ -133,11 +140,18 @@ func (m *txSortedMap) Filter(filter func(*types.Transaction) bool) types.Transac
 
 func (m *txSortedMap) reheap() {
 	*m.index = make([]uint64, 0, len(m.items))
+
 	for nonce := range m.items {
 		*m.index = append(*m.index, nonce)
 	}
+
 	heap.Init(m.index)
+
 	m.cache = nil
+	m.isEmpty = true
+	m.cacheOnce = sync.Once{}
+
+	resetCacheGauge.Inc(1)
 }
 
 // filter is identical to Filter, but **does not** regenerate the heap. This method
@@ -154,6 +168,10 @@ func (m *txSortedMap) filter(filter func(*types.Transaction) bool) types.Transac
 	}
 	if len(removed) > 0 {
 		m.cache = nil
+		m.isEmpty = true
+		m.cacheOnce = sync.Once{}
+
+		resetCacheGauge.Inc(1)
 	}
 	return removed
 }
@@ -168,10 +186,12 @@ func (m *txSortedMap) Cap(threshold int) types.Transactions {
 	if len(m.items) <= threshold {
 		return nil
 	}
+
 	// Otherwise gather and drop the highest nonce'd transactions
 	var drops types.Transactions
 
 	sort.Sort(*m.index)
+
 	for size := len(m.items); size > threshold; size-- {
 		drops = append(drops, m.items[(*m.index)[size-1]])
 		delete(m.items, (*m.index)[size-1])
@@ -199,15 +219,23 @@ func (m *txSortedMap) Remove(nonce uint64) bool {
 	if !ok {
 		return false
 	}
+
 	// Otherwise delete the transaction and fix the heap index
 	for i := 0; i < m.index.Len(); i++ {
 		if (*m.index)[i] == nonce {
 			heap.Remove(m.index, i)
+
 			break
 		}
 	}
+
 	delete(m.items, nonce)
+
 	m.cache = nil
+	m.isEmpty = true
+	m.cacheOnce = sync.Once{}
+
+	resetCacheGauge.Inc(1)
 
 	return true
 }
@@ -227,14 +255,21 @@ func (m *txSortedMap) Ready(start uint64) types.Transactions {
 	if m.index.Len() == 0 || (*m.index)[0] > start {
 		return nil
 	}
+
 	// Otherwise start accumulating incremental transactions
 	var ready types.Transactions
+
 	for next := (*m.index)[0]; m.index.Len() > 0 && (*m.index)[0] == next; next++ {
 		ready = append(ready, m.items[next])
 		delete(m.items, next)
 		heap.Pop(m.index)
 	}
+
 	m.cache = nil
+	m.isEmpty = true
+	m.cacheOnce = sync.Once{}
+
+	resetCacheGauge.Inc(1)
 
 	return ready
 }
@@ -249,13 +284,33 @@ func (m *txSortedMap) Len() int {
 
 func (m *txSortedMap) flatten() types.Transactions {
 	// If the sorting was not cached yet, create and cache it
-	if m.cache == nil {
-		m.cache = make(types.Transactions, 0, len(m.items))
-		for _, tx := range m.items {
-			m.cache = append(m.cache, tx)
-		}
-		sort.Sort(types.TxByNonce(m.cache))
+	m.m.RLock()
+	isEmpty := m.isEmpty
+	m.m.RUnlock()
+
+	if isEmpty {
+		m.cacheOnce.Do(func() {
+			m.m.RLock()
+			cache := make(types.Transactions, 0, len(m.items))
+
+			for _, tx := range m.items {
+				cache = append(cache, tx)
+			}
+
+			m.m.RUnlock()
+
+			// exclude sorting from locks
+			sort.Sort(types.TxByNonce(cache))
+
+			m.m.Lock()
+			m.cache = cache
+			m.isEmpty = false
+			m.m.Unlock()
+
+			reinitCacheGauge.Inc(1)
+		})
 	}
+
 	return m.cache
 }
 
@@ -263,21 +318,13 @@ func (m *txSortedMap) flatten() types.Transactions {
 // sorted internal representation. The result of the sorting is cached in case
 // it's requested again before any modifications are made to the contents.
 func (m *txSortedMap) Flatten() types.Transactions {
-	m.m.Lock()
-	defer m.m.Unlock()
-
 	// Copy the cache to prevent accidental modifications
-	txs := m.flatten()
-
-	return txs
+	return m.flatten()
 }
 
 // LastElement returns the last element of a flattened list, thus, the
 // transaction with the highest nonce
 func (m *txSortedMap) LastElement() *types.Transaction {
-	m.m.Lock()
-	defer m.m.Unlock()
-
 	cache := m.flatten()
 	return cache[len(cache)-1]
 }
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 41e5829ea3..4c9953f57b 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -131,6 +131,9 @@ var (
 	localGauge   = metrics.NewRegisteredGauge("txpool/local", nil)
 	slotsGauge   = metrics.NewRegisteredGauge("txpool/slots", nil)
 
+	resetCacheGauge  = metrics.NewRegisteredGauge("txpool/resetcache", nil)
+	reinitCacheGauge = metrics.NewRegisteredGauge("txpool/reinittcache", nil)
+
 	reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil)
 )
 
@@ -1383,7 +1386,7 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 
 		var promoteAddrs []common.Address
 
-		tracing.ElapsedTime(ctx, span, "dirty accounts flattening", func(_ context.Context, innerSpan trace.Span) {
+		tracing.ElapsedTime(ctx, span, "01 dirty accounts flattening", func(_ context.Context, innerSpan trace.Span) {
 			if dirtyAccounts != nil && reset == nil {
 				// Only dirty accounts need to be promoted, unless we're resetting.
 				// For resets, all addresses in the tx queue will be promoted and
@@ -1397,15 +1400,15 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 			)
 		})
 
-		tracing.ElapsedTime(ctx, span, "obtaining pool.WMutex", func(_ context.Context, _ trace.Span) {
+		tracing.ElapsedTime(ctx, span, "02 obtaining pool.WMutex", func(_ context.Context, _ trace.Span) {
 			pool.mu.Lock()
 		})
 
 		if reset != nil {
-			tracing.ElapsedTime(ctx, span, "reset-head reorg", func(_ context.Context, innerSpan trace.Span) {
+			tracing.ElapsedTime(ctx, span, "03 reset-head reorg", func(_ context.Context, innerSpan trace.Span) {
 
 				// Reset from the old head to the new, rescheduling any reorged transactions
-				tracing.ElapsedTime(ctx, innerSpan, "reset-head-itself reorg", func(_ context.Context, innerSpan trace.Span) {
+				tracing.ElapsedTime(ctx, innerSpan, "04 reset-head-itself reorg", func(_ context.Context, innerSpan trace.Span) {
 					pool.reset(reset.oldHead, reset.newHead)
 				})
 
@@ -1439,16 +1442,16 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 		// Check for pending transactions for every account that sent new ones
 		var promoted []*types.Transaction
 
-		tracing.ElapsedTime(ctx, span, "promoteExecutables", func(_ context.Context, _ trace.Span) {
+		tracing.ElapsedTime(ctx, span, "05 promoteExecutables", func(_ context.Context, _ trace.Span) {
 			promoted = pool.promoteExecutables(promoteAddrs)
 		})
 
 		tracing.SetAttributes(
 			span,
-			attribute.Int("promoteAddresses-reset-head", len(promoteAddrs)),
-			attribute.Int("all", pool.all.Count()),
-			attribute.Int("pending", len(pool.pending)),
-			attribute.Int("queue", len(pool.queue)),
+			attribute.Int("count.promoteAddresses-reset-head", len(promoteAddrs)),
+			attribute.Int("count.all", pool.all.Count()),
+			attribute.Int("count.pending", len(pool.pending)),
+			attribute.Int("count.queue", len(pool.queue)),
 		)
 
 		// If a new block appeared, validate the pool of pending transactions. This will
@@ -1458,49 +1461,55 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 		if reset != nil {
 			tracing.ElapsedTime(ctx, span, "new block", func(_ context.Context, innerSpan trace.Span) {
 
-				tracing.ElapsedTime(ctx, innerSpan, "demoteUnexecutables", func(_ context.Context, _ trace.Span) {
+				tracing.ElapsedTime(ctx, innerSpan, "06 demoteUnexecutables", func(_ context.Context, _ trace.Span) {
 					pool.demoteUnexecutables()
 				})
 
-				if reset.newHead != nil {
-					if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
-						// london fork enabled, reset given the base fee
-						pendingBaseFee := misc.CalcBaseFeeUint(pool.chainconfig, reset.newHead)
-						pool.priced.SetBaseFee(pendingBaseFee)
-					} else {
-						// london fork not enabled, reheap to "reset" the priced list
-						pool.priced.Reheap()
+				var nonces map[common.Address]uint64
+
+				tracing.ElapsedTime(ctx, innerSpan, "07 set_base_fee", func(_ context.Context, _ trace.Span) {
+					if reset.newHead != nil {
+						if pool.chainconfig.IsLondon(new(big.Int).Add(reset.newHead.Number, big.NewInt(1))) {
+							// london fork enabled, reset given the base fee
+							pendingBaseFee := misc.CalcBaseFeeUint(pool.chainconfig, reset.newHead)
+							pool.priced.SetBaseFee(pendingBaseFee)
+						} else {
+							// london fork not enabled, reheap to "reset" the priced list
+							pool.priced.Reheap()
+						}
 					}
-				}
 
-				// Update all accounts to the latest known pending nonce
-				nonces := make(map[common.Address]uint64, len(pool.pending))
+					// Update all accounts to the latest known pending nonce
+					nonces = make(map[common.Address]uint64, len(pool.pending))
+				})
 
-				tracing.ElapsedTime(ctx, innerSpan, "obtaining pendingMu.RMutex", func(_ context.Context, innerSpan trace.Span) {
+				tracing.ElapsedTime(ctx, innerSpan, "08 obtaining pendingMu.RMutex", func(_ context.Context, _ trace.Span) {
 					pool.pendingMu.RLock()
 				})
 
 				var highestPending *types.Transaction
 
-				for addr, list := range pool.pending {
-					highestPending = list.LastElement()
-					nonces[addr] = highestPending.Nonce() + 1
-				}
+				tracing.ElapsedTime(ctx, innerSpan, "09 fill nonces", func(_ context.Context, innerSpan trace.Span) {
+					for addr, list := range pool.pending {
+						highestPending = list.LastElement()
+						nonces[addr] = highestPending.Nonce() + 1
+					}
+				})
 
 				pool.pendingMu.RUnlock()
 
-				tracing.ElapsedTime(ctx, innerSpan, "reset nonces", func(_ context.Context, _ trace.Span) {
+				tracing.ElapsedTime(ctx, innerSpan, "10 reset nonces", func(_ context.Context, _ trace.Span) {
 					pool.pendingNonces.setAll(nonces)
 				})
 			})
 		}
 
 		// Ensure pool.queue and pool.pending sizes stay within the configured limits.
-		tracing.ElapsedTime(ctx, span, "truncatePending", func(_ context.Context, _ trace.Span) {
+		tracing.ElapsedTime(ctx, span, "11 truncatePending", func(_ context.Context, _ trace.Span) {
 			pool.truncatePending()
 		})
 
-		tracing.ElapsedTime(ctx, span, "truncateQueue", func(_ context.Context, _ trace.Span) {
+		tracing.ElapsedTime(ctx, span, "12 truncateQueue", func(_ context.Context, _ trace.Span) {
 			pool.truncateQueue()
 		})
 
@@ -1510,7 +1519,7 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 		pool.mu.Unlock()
 
 		// Notify subsystems for newly added transactions
-		tracing.ElapsedTime(ctx, span, "notify about new transactions", func(_ context.Context, _ trace.Span) {
+		tracing.ElapsedTime(ctx, span, "13 notify about new transactions", func(_ context.Context, _ trace.Span) {
 			for _, tx := range promoted {
 				addr, _ := types.Sender(pool.signer, tx)
 
@@ -1523,7 +1532,7 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 		})
 
 		if len(events) > 0 {
-			tracing.ElapsedTime(ctx, span, "txFeed", func(_ context.Context, _ trace.Span) {
+			tracing.ElapsedTime(ctx, span, "14 txFeed", func(_ context.Context, _ trace.Span) {
 				var txs []*types.Transaction
 
 				for _, set := range events {
@@ -1533,7 +1542,6 @@ func (pool *TxPool) runReorg(ctx context.Context, done chan struct{}, reset *txp
 				pool.txFeed.Send(NewTxsEvent{txs})
 			})
 		}
-
 	})
 }
 

From 5b017ac3a6ccac136ca7816f8133900824a657ca Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Fri, 28 Oct 2022 18:41:46 +0400
Subject: [PATCH 59/96] fix

---
 Makefile                       | 2 +-
 eth/bor_checkpoint_verifier.go | 1 +
 miner/worker.go                | 2 ++
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index 6e1e472a03..addbc7573c 100644
--- a/Makefile
+++ b/Makefile
@@ -75,7 +75,7 @@ lint:
 
 lintci-deps:
 	rm -f ./build/bin/golangci-lint
-	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b ./build/bin v1.48.0
+	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b ./build/bin v1.50.1
 
 goimports:
 	goimports -local "$(PACKAGE)" -w .
diff --git a/eth/bor_checkpoint_verifier.go b/eth/bor_checkpoint_verifier.go
index 61e8c382e1..ad81eb6116 100644
--- a/eth/bor_checkpoint_verifier.go
+++ b/eth/bor_checkpoint_verifier.go
@@ -26,6 +26,7 @@ func newCheckpointVerifier(verifyFn func(ctx context.Context, handler *ethHandle
 		)
 
 		// check if we have the checkpoint blocks
+		//nolint:contextcheck
 		head := handler.ethAPI.BlockNumber()
 		if head < hexutil.Uint64(endBlock) {
 			log.Debug("Head block behind checkpoint block", "head", head, "checkpoint end block", endBlock)
diff --git a/miner/worker.go b/miner/worker.go
index 66b572f5a6..ac8640fd4a 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -569,9 +569,11 @@ func (w *worker) mainLoop(ctx context.Context) {
 	for {
 		select {
 		case req := <-w.newWorkCh:
+			//nolint:contextcheck
 			w.commitWork(req.ctx, req.interrupt, req.noempty, req.timestamp)
 
 		case req := <-w.getWorkCh:
+			//nolint:contextcheck
 			block, err := w.generateWork(req.ctx, req.params)
 			if err != nil {
 				req.err = err

From 03385b6d4abd5b07dc1f5c1a6ec77b1fc048c6eb Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Fri, 28 Oct 2022 21:09:46 +0400
Subject: [PATCH 60/96] cache hit/miss

---
 core/tx_list.go | 6 ++++++
 core/tx_pool.go | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/core/tx_list.go b/core/tx_list.go
index 858adb9d9e..0df3125f61 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -93,6 +93,7 @@ func (m *txSortedMap) Put(tx *types.Transaction) {
 
 	m.items[nonce] = tx
 	m.cache = nil
+
 	m.isEmpty = true
 	m.cacheOnce = sync.Once{}
 }
@@ -115,6 +116,7 @@ func (m *txSortedMap) Forward(threshold uint64) types.Transactions {
 
 	// If we had a cached order, shift the front
 	if m.cache != nil {
+		hitCacheCounter.Inc(1)
 		m.cache = m.cache[len(removed):]
 	}
 
@@ -309,6 +311,10 @@ func (m *txSortedMap) flatten() types.Transactions {
 
 			reinitCacheGauge.Inc(1)
 		})
+
+		missCacheCounter.Inc(1)
+	} else {
+		hitCacheCounter.Inc(1)
 	}
 
 	return m.cache
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 4c9953f57b..77d98bcf0e 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -133,6 +133,8 @@ var (
 
 	resetCacheGauge  = metrics.NewRegisteredGauge("txpool/resetcache", nil)
 	reinitCacheGauge = metrics.NewRegisteredGauge("txpool/reinittcache", nil)
+	hitCacheCounter  = metrics.NewRegisteredCounter("txpool/cachehit", nil)
+	missCacheCounter = metrics.NewRegisteredCounter("txpool/cachemiss", nil)
 
 	reheapTimer = metrics.NewRegisteredTimer("txpool/reheap", nil)
 )

From 79e66f993b9e794f9383156f6fc7ccc22a8b7c9a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 29 Oct 2022 15:02:12 +0400
Subject: [PATCH 61/96] less locks on evict

---
 core/tx_pool.go | 38 ++++++++++++++++++++++++++++++++------
 1 file changed, 32 insertions(+), 6 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 77d98bcf0e..529f73a1a8 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -402,22 +402,45 @@ func (pool *TxPool) loop() {
 
 		// Handle inactive account transaction eviction
 		case <-evict.C:
-			pool.mu.Lock()
+			now := time.Now()
+
+			var (
+				list     types.Transactions
+				tx       *types.Transaction
+				toRemove []common.Hash
+			)
+
+			pool.mu.RLock()
 			for addr := range pool.queue {
 				// Skip local transactions from the eviction mechanism
 				if pool.locals.contains(addr) {
 					continue
 				}
+
 				// Any non-locals old enough should be removed
-				if time.Since(pool.beats[addr]) > pool.config.Lifetime {
-					list := pool.queue[addr].Flatten()
-					for _, tx := range list {
-						pool.removeTx(tx.Hash(), true)
+				if now.Sub(pool.beats[addr]) > pool.config.Lifetime {
+					list = pool.queue[addr].Flatten()
+					for _, tx = range list {
+						toRemove = append(toRemove, tx.Hash())
 					}
+
 					queuedEvictionMeter.Mark(int64(len(list)))
 				}
 			}
-			pool.mu.Unlock()
+
+			pool.mu.RUnlock()
+
+			if len(toRemove) > 0 {
+				pool.mu.Lock()
+
+				var hash common.Hash
+
+				for _, hash = range toRemove {
+					pool.removeTx(hash, true)
+				}
+
+				pool.mu.Unlock()
+			}
 
 		// Handle local transaction journal rotation
 		case <-journal.C:
@@ -1212,6 +1235,7 @@ func (pool *TxPool) removeTx(hash common.Hash, outofbound bool) {
 	if tx == nil {
 		return
 	}
+
 	addr, _ := types.Sender(pool.signer, tx) // already validated during insertion
 
 	// Remove it from the list of known transactions
@@ -1219,6 +1243,7 @@ func (pool *TxPool) removeTx(hash common.Hash, outofbound bool) {
 	if outofbound {
 		pool.priced.Removed(1)
 	}
+
 	if pool.locals.contains(addr) {
 		localGauge.Dec(1)
 	}
@@ -1234,6 +1259,7 @@ func (pool *TxPool) removeTx(hash common.Hash, outofbound bool) {
 			if pending.Empty() {
 				delete(pool.pending, addr)
 			}
+
 			pool.pendingMu.Unlock()
 
 			// Postpone any invalidated transactions

From 4a1cd65c92a77a615970a668285142f0e9622463 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 30 Oct 2022 11:44:46 +0400
Subject: [PATCH 62/96] remove once

---
 core/tx_list.go | 63 +++++++++++++++++++++++++++----------------------
 1 file changed, 35 insertions(+), 28 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 0df3125f61..a10ff317ff 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -58,9 +58,9 @@ type txSortedMap struct {
 	index *nonceHeap                    // Heap of nonces of all the stored transactions (non-strict mode)
 	m     sync.RWMutex
 
-	cache     types.Transactions // Cache of the transactions already sorted
-	isEmpty   bool
-	cacheOnce sync.Once
+	cache   types.Transactions // Cache of the transactions already sorted
+	isEmpty bool
+	cacheMu sync.RWMutex
 }
 
 // newTxSortedMap creates a new nonce-sorted transaction map.
@@ -92,10 +92,11 @@ func (m *txSortedMap) Put(tx *types.Transaction) {
 	}
 
 	m.items[nonce] = tx
-	m.cache = nil
 
+	m.cacheMu.Lock()
 	m.isEmpty = true
-	m.cacheOnce = sync.Once{}
+	m.cache = nil
+	m.cacheMu.Unlock()
 }
 
 // Forward removes all transactions from the map with a nonce lower than the
@@ -149,9 +150,10 @@ func (m *txSortedMap) reheap() {
 
 	heap.Init(m.index)
 
+	m.cacheMu.Lock()
 	m.cache = nil
 	m.isEmpty = true
-	m.cacheOnce = sync.Once{}
+	m.cacheMu.Unlock()
 
 	resetCacheGauge.Inc(1)
 }
@@ -169,9 +171,10 @@ func (m *txSortedMap) filter(filter func(*types.Transaction) bool) types.Transac
 		}
 	}
 	if len(removed) > 0 {
+		m.cacheMu.Lock()
 		m.cache = nil
 		m.isEmpty = true
-		m.cacheOnce = sync.Once{}
+		m.cacheMu.Unlock()
 
 		resetCacheGauge.Inc(1)
 	}
@@ -233,9 +236,10 @@ func (m *txSortedMap) Remove(nonce uint64) bool {
 
 	delete(m.items, nonce)
 
+	m.cacheMu.Lock()
 	m.cache = nil
 	m.isEmpty = true
-	m.cacheOnce = sync.Once{}
+	m.cacheMu.Unlock()
 
 	resetCacheGauge.Inc(1)
 
@@ -267,9 +271,10 @@ func (m *txSortedMap) Ready(start uint64) types.Transactions {
 		heap.Pop(m.index)
 	}
 
+	m.cacheMu.Lock()
 	m.cache = nil
 	m.isEmpty = true
-	m.cacheOnce = sync.Once{}
+	m.cacheMu.Unlock()
 
 	resetCacheGauge.Inc(1)
 
@@ -286,37 +291,39 @@ func (m *txSortedMap) Len() int {
 
 func (m *txSortedMap) flatten() types.Transactions {
 	// If the sorting was not cached yet, create and cache it
-	m.m.RLock()
-	isEmpty := m.isEmpty
-	m.m.RUnlock()
+	m.cacheMu.Lock()
 
-	if isEmpty {
-		m.cacheOnce.Do(func() {
-			m.m.RLock()
-			cache := make(types.Transactions, 0, len(m.items))
+	if m.isEmpty {
+		m.isEmpty = false // to simulate sync.Once
 
-			for _, tx := range m.items {
-				cache = append(cache, tx)
-			}
+		m.cacheMu.Unlock()
 
-			m.m.RUnlock()
+		m.m.RLock()
+		cache := make(types.Transactions, 0, len(m.items))
 
-			// exclude sorting from locks
-			sort.Sort(types.TxByNonce(cache))
+		for _, tx := range m.items {
+			cache = append(cache, tx)
+		}
+
+		m.m.RUnlock()
 
-			m.m.Lock()
-			m.cache = cache
-			m.isEmpty = false
-			m.m.Unlock()
+		// exclude sorting from locks
+		sort.Sort(types.TxByNonce(cache))
 
-			reinitCacheGauge.Inc(1)
-		})
+		m.m.Lock()
+		m.cache = cache
+		m.m.Unlock()
 
+		reinitCacheGauge.Inc(1)
 		missCacheCounter.Inc(1)
+
+		m.cacheMu.Lock()
 	} else {
 		hitCacheCounter.Inc(1)
 	}
 
+	m.cacheMu.RUnlock()
+
 	return m.cache
 }
 

From 1cd8de54be4eb0c113a61b386aec7965ee96d744 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 30 Oct 2022 11:46:33 +0400
Subject: [PATCH 63/96] remove once

---
 core/tx_list.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index a10ff317ff..3881e8839b 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -316,14 +316,12 @@ func (m *txSortedMap) flatten() types.Transactions {
 
 		reinitCacheGauge.Inc(1)
 		missCacheCounter.Inc(1)
-
-		m.cacheMu.Lock()
 	} else {
+		m.cacheMu.Unlock()
+
 		hitCacheCounter.Inc(1)
 	}
 
-	m.cacheMu.RUnlock()
-
 	return m.cache
 }
 

From 1571a0693d8f194a3434f5804af7391485c9dd5a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 30 Oct 2022 11:57:23 +0400
Subject: [PATCH 64/96] switch off pprof

---
 miner/worker.go | 86 +++++++++++++++++++++++++------------------------
 1 file changed, 44 insertions(+), 42 deletions(-)

diff --git a/miner/worker.go b/miner/worker.go
index ac8640fd4a..d2f9cc5a57 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1219,61 +1219,63 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		remoteTxs      map[common.Address]types.Transactions
 	)
 
-	doneCh := make(chan struct{})
+	/*
 
-	defer func() {
-		close(doneCh)
-	}()
+		doneCh := make(chan struct{})
 
-	go func(number uint64) {
-		closeFn := func() error {
-			return nil
-		}
+		defer func() {
+			close(doneCh)
+		}()
+			go func(number uint64) {
+				closeFn := func() error {
+					return nil
+				}
 
-		for {
-			select {
-			case <-time.After(150 * time.Millisecond):
-				// Check if we've not crossed limit
-				if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 {
-					log.Info("Completed profiling", "attempt", attempt)
+				for {
+					select {
+					case <-time.After(150 * time.Millisecond):
+						// Check if we've not crossed limit
+						if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 {
+							log.Info("Completed profiling", "attempt", attempt)
 
-					return
-				}
+							return
+						}
 
-				log.Info("Starting profiling in fill transactions", "number", number)
+						log.Info("Starting profiling in fill transactions", "number", number)
 
-				dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
-				if err != nil {
-					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
-					return
-				}
+						dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
+						if err != nil {
+							log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+							return
+						}
 
-				// grab the cpu profile
-				closeFnInternal, err := startProfiler("cpu", dir, number)
-				if err != nil {
-					log.Error("Error in profiling", "path", dir, "number", number, "err", err)
-					return
-				}
+						// grab the cpu profile
+						closeFnInternal, err := startProfiler("cpu", dir, number)
+						if err != nil {
+							log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+							return
+						}
 
-				closeFn = func() error {
-					err := closeFnInternal()
+						closeFn = func() error {
+							err := closeFnInternal()
 
-					log.Info("Completed profiling", "path", dir, "number", number, "error", err)
+							log.Info("Completed profiling", "path", dir, "number", number, "error", err)
 
-					return nil
-				}
+							return nil
+						}
 
-			case <-doneCh:
-				err := closeFn()
+					case <-doneCh:
+						err := closeFn()
 
-				if err != nil {
-					log.Info("closing fillTransactions", "number", number, "error", err)
-				}
+						if err != nil {
+							log.Info("closing fillTransactions", "number", number, "error", err)
+						}
 
-				return
-			}
-		}
-	}(env.header.Number.Uint64())
+						return
+					}
+				}
+			}(env.header.Number.Uint64())
+	*/
 
 	tracing.Exec(ctx, "", "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 

From b39fe2ff4aba49a96e264e0425cf0e6c03165f24 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 30 Oct 2022 17:14:53 +0400
Subject: [PATCH 65/96] fix data race

---
 core/tx_list.go |  4 +--
 miner/worker.go | 79 +++++++++++++++++++++++++------------------------
 2 files changed, 43 insertions(+), 40 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 3881e8839b..13aa0cf1e8 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -310,9 +310,9 @@ func (m *txSortedMap) flatten() types.Transactions {
 		// exclude sorting from locks
 		sort.Sort(types.TxByNonce(cache))
 
-		m.m.Lock()
+		m.cacheMu.Lock()
 		m.cache = cache
-		m.m.Unlock()
+		m.cacheMu.Unlock()
 
 		reinitCacheGauge.Inc(1)
 		missCacheCounter.Inc(1)
diff --git a/miner/worker.go b/miner/worker.go
index d2f9cc5a57..eece200d44 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1219,63 +1219,66 @@ func (w *worker) fillTransactions(ctx context.Context, interrupt *int32, env *en
 		remoteTxs      map[common.Address]types.Transactions
 	)
 
-	/*
+	// TODO: move to config or RPC
+	const profiling = false
 
+	if profiling {
 		doneCh := make(chan struct{})
 
 		defer func() {
 			close(doneCh)
 		}()
-			go func(number uint64) {
-				closeFn := func() error {
-					return nil
-				}
 
-				for {
-					select {
-					case <-time.After(150 * time.Millisecond):
-						// Check if we've not crossed limit
-						if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 {
-							log.Info("Completed profiling", "attempt", attempt)
+		go func(number uint64) {
+			closeFn := func() error {
+				return nil
+			}
 
-							return
-						}
+			for {
+				select {
+				case <-time.After(150 * time.Millisecond):
+					// Check if we've not crossed limit
+					if attempt := atomic.AddInt32(w.profileCount, 1); attempt >= 10 {
+						log.Info("Completed profiling", "attempt", attempt)
 
-						log.Info("Starting profiling in fill transactions", "number", number)
+						return
+					}
 
-						dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
-						if err != nil {
-							log.Error("Error in profiling", "path", dir, "number", number, "err", err)
-							return
-						}
+					log.Info("Starting profiling in fill transactions", "number", number)
 
-						// grab the cpu profile
-						closeFnInternal, err := startProfiler("cpu", dir, number)
-						if err != nil {
-							log.Error("Error in profiling", "path", dir, "number", number, "err", err)
-							return
-						}
+					dir, err := os.MkdirTemp("", fmt.Sprintf("bor-traces-%s-", time.Now().UTC().Format("2006-01-02-150405Z")))
+					if err != nil {
+						log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+						return
+					}
 
-						closeFn = func() error {
-							err := closeFnInternal()
+					// grab the cpu profile
+					closeFnInternal, err := startProfiler("cpu", dir, number)
+					if err != nil {
+						log.Error("Error in profiling", "path", dir, "number", number, "err", err)
+						return
+					}
 
-							log.Info("Completed profiling", "path", dir, "number", number, "error", err)
+					closeFn = func() error {
+						err := closeFnInternal()
 
-							return nil
-						}
+						log.Info("Completed profiling", "path", dir, "number", number, "error", err)
 
-					case <-doneCh:
-						err := closeFn()
+						return nil
+					}
 
-						if err != nil {
-							log.Info("closing fillTransactions", "number", number, "error", err)
-						}
+				case <-doneCh:
+					err := closeFn()
 
-						return
+					if err != nil {
+						log.Info("closing fillTransactions", "number", number, "error", err)
 					}
+
+					return
 				}
-			}(env.header.Number.Uint64())
-	*/
+			}
+		}(env.header.Number.Uint64())
+	}
 
 	tracing.Exec(ctx, "", "worker.SplittingTransactions", func(ctx context.Context, span trace.Span) {
 

From e2be0694ff4b063649e9c2017f18bed050369d7f Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sun, 30 Oct 2022 17:23:30 +0400
Subject: [PATCH 66/96] fix data race

---
 core/tx_list.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 13aa0cf1e8..a68d0cc054 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -292,6 +292,7 @@ func (m *txSortedMap) Len() int {
 func (m *txSortedMap) flatten() types.Transactions {
 	// If the sorting was not cached yet, create and cache it
 	m.cacheMu.Lock()
+	defer m.cacheMu.Unlock()
 
 	if m.isEmpty {
 		m.isEmpty = false // to simulate sync.Once
@@ -312,12 +313,12 @@ func (m *txSortedMap) flatten() types.Transactions {
 
 		m.cacheMu.Lock()
 		m.cache = cache
-		m.cacheMu.Unlock()
+		// m.cacheMu.Unlock() - deferred
 
 		reinitCacheGauge.Inc(1)
 		missCacheCounter.Inc(1)
 	} else {
-		m.cacheMu.Unlock()
+		// m.cacheMu.Unlock() - deferred
 
 		hitCacheCounter.Inc(1)
 	}

From 323c2f847962a7b9806782da4a950ccfe60be896 Mon Sep 17 00:00:00 2001
From: Shivam Sharma <shivam691999@gmail.com>
Date: Mon, 31 Oct 2022 12:31:31 +0530
Subject: [PATCH 67/96] add : sealed total/empty blocks metric gauge

---
 miner/worker.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/miner/worker.go b/miner/worker.go
index eece200d44..70c652a3c1 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -45,6 +45,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
 )
@@ -89,6 +90,12 @@ const (
 	staleThreshold = 7
 )
 
+// metrics gauge to track total and empty blocks sealed by a miner
+var (
+	sealedBlocksGauge      = metrics.NewRegisteredGauge("worker/sealedBlocks", nil)
+	sealedEmptyBlocksGauge = metrics.NewRegisteredGauge("worker/sealedEmptyBlocks", nil)
+)
+
 // environment is the worker's current environment and holds all
 // information of the sealing block generation.
 type environment struct {
@@ -823,6 +830,11 @@ func (w *worker) resultLoop() {
 			// Broadcast the block and announce chain insertion event
 			w.mux.Post(core.NewMinedBlockEvent{Block: block})
 
+			sealedBlocksGauge.Inc(1)
+			if block.Transactions().Len() == 0 {
+				sealedEmptyBlocksGauge.Inc(1)
+			}
+
 			// Insert the block into the set of pending ones to resultLoop for confirmations
 			w.unconfirmed.Insert(block.NumberU64(), block.Hash())
 		case <-w.exitCh:

From abc01490da78cd71b805ce369ad55048b633c3c0 Mon Sep 17 00:00:00 2001
From: Shivam Sharma <shivam691999@gmail.com>
Date: Mon, 31 Oct 2022 13:34:00 +0530
Subject: [PATCH 68/96] add : RPC debug_getTraceStack

---
 eth/api_backend.go          | 5 +++++
 internal/web3ext/web3ext.go | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/eth/api_backend.go b/eth/api_backend.go
index 2c93e60d87..d0ce9bdada 100644
--- a/eth/api_backend.go
+++ b/eth/api_backend.go
@@ -20,6 +20,7 @@ import (
 	"context"
 	"errors"
 	"math/big"
+	"runtime/debug"
 	"time"
 
 	"github.com/ethereum/go-ethereum"
@@ -374,3 +375,7 @@ func (b *EthAPIBackend) GetCheckpointWhitelist() map[uint64]common.Hash {
 func (b *EthAPIBackend) PurgeCheckpointWhitelist() {
 	b.eth.Downloader().ChainValidator.PurgeCheckpointWhitelist()
 }
+
+func (b *EthAPIBackend) GetTraceStack() string {
+	return string(debug.Stack())
+}
diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go
index dcdd5baf23..64ceb5c42e 100644
--- a/internal/web3ext/web3ext.go
+++ b/internal/web3ext/web3ext.go
@@ -484,6 +484,11 @@ web3._extend({
 			call: 'debug_purgeCheckpointWhitelist',
 			params: 0,
 		}),
+		new web3._extend.Method({
+			name: 'getTraceStack',
+			call: 'debug_getTraceStack',
+			params: 0,
+		}),
 	],
 	properties: []
 });

From 83ceb46fc06bfe67abb5b4b974cc5299138ddcbd Mon Sep 17 00:00:00 2001
From: Shivam Sharma <shivam691999@gmail.com>
Date: Mon, 31 Oct 2022 14:18:30 +0530
Subject: [PATCH 69/96] fix : RPC debug_getTraceStack

---
 eth/api_backend.go     | 5 -----
 internal/ethapi/api.go | 6 ++++++
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/eth/api_backend.go b/eth/api_backend.go
index d0ce9bdada..2c93e60d87 100644
--- a/eth/api_backend.go
+++ b/eth/api_backend.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"errors"
 	"math/big"
-	"runtime/debug"
 	"time"
 
 	"github.com/ethereum/go-ethereum"
@@ -375,7 +374,3 @@ func (b *EthAPIBackend) GetCheckpointWhitelist() map[uint64]common.Hash {
 func (b *EthAPIBackend) PurgeCheckpointWhitelist() {
 	b.eth.Downloader().ChainValidator.PurgeCheckpointWhitelist()
 }
-
-func (b *EthAPIBackend) GetTraceStack() string {
-	return string(debug.Stack())
-}
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index a71ec3bd87..a1834fa4a0 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -21,6 +21,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"runtime/debug"
 	"strings"
 	"time"
 
@@ -2207,6 +2208,11 @@ func (api *PrivateDebugAPI) PurgeCheckpointWhitelist() {
 	api.b.PurgeCheckpointWhitelist()
 }
 
+// GetTraceStack() returns the current trace stack
+func (api *PrivateDebugAPI) GetTraceStack() string {
+	return string(debug.Stack())
+}
+
 // PublicNetAPI offers network related RPC methods
 type PublicNetAPI struct {
 	net            *p2p.Server

From dc55f1da5366f547464e5b406b1d7c4a0344499e Mon Sep 17 00:00:00 2001
From: Shivam Sharma <shivam691999@gmail.com>
Date: Mon, 31 Oct 2022 15:04:23 +0530
Subject: [PATCH 70/96] fix : RPC debug_getTraceStack for all go-routines

---
 internal/ethapi/api.go | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index a1834fa4a0..a1305bb101 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -21,7 +21,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
-	"runtime/debug"
+	"runtime"
 	"strings"
 	"time"
 
@@ -2210,7 +2210,15 @@ func (api *PrivateDebugAPI) PurgeCheckpointWhitelist() {
 
 // GetTraceStack() returns the current trace stack
 func (api *PrivateDebugAPI) GetTraceStack() string {
-	return string(debug.Stack())
+	buf := make([]byte, 1024)
+	for {
+		n := runtime.Stack(buf, true)
+		if n < len(buf) {
+			return string((buf[:n]))
+		}
+		buf = make([]byte, 2*len(buf))
+	}
+
 }
 
 // PublicNetAPI offers network related RPC methods

From 409886a72d96ad5c47d194d94a09bb783e6f8544 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Tue, 1 Nov 2022 14:06:15 +0400
Subject: [PATCH 71/96] linters

---
 internal/ethapi/api.go | 8 +++++---
 miner/worker.go        | 9 +++++----
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index a1305bb101..21fc81918e 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -2208,17 +2208,19 @@ func (api *PrivateDebugAPI) PurgeCheckpointWhitelist() {
 	api.b.PurgeCheckpointWhitelist()
 }
 
-// GetTraceStack() returns the current trace stack
+// GetTraceStack returns the current trace stack
 func (api *PrivateDebugAPI) GetTraceStack() string {
 	buf := make([]byte, 1024)
+
 	for {
 		n := runtime.Stack(buf, true)
+
 		if n < len(buf) {
-			return string((buf[:n]))
+			return string(buf)
 		}
+
 		buf = make([]byte, 2*len(buf))
 	}
-
 }
 
 // PublicNetAPI offers network related RPC methods
diff --git a/miner/worker.go b/miner/worker.go
index 70c652a3c1..0137a74008 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -92,8 +92,8 @@ const (
 
 // metrics gauge to track total and empty blocks sealed by a miner
 var (
-	sealedBlocksGauge      = metrics.NewRegisteredGauge("worker/sealedBlocks", nil)
-	sealedEmptyBlocksGauge = metrics.NewRegisteredGauge("worker/sealedEmptyBlocks", nil)
+	sealedBlocksCounter      = metrics.NewRegisteredCounter("worker/sealedBlocks", nil)
+	sealedEmptyBlocksCounter = metrics.NewRegisteredCounter("worker/sealedEmptyBlocks", nil)
 )
 
 // environment is the worker's current environment and holds all
@@ -830,9 +830,10 @@ func (w *worker) resultLoop() {
 			// Broadcast the block and announce chain insertion event
 			w.mux.Post(core.NewMinedBlockEvent{Block: block})
 
-			sealedBlocksGauge.Inc(1)
+			sealedBlocksCounter.Inc(1)
+
 			if block.Transactions().Len() == 0 {
-				sealedEmptyBlocksGauge.Inc(1)
+				sealedEmptyBlocksCounter.Inc(1)
 			}
 
 			// Insert the block into the set of pending ones to resultLoop for confirmations

From 665f6d2d6acfe5b1e6a5f95695c4382061fe65cd Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 2 Nov 2022 17:07:48 +0400
Subject: [PATCH 72/96] add data race test on txpool

---
 Makefile             |   5 +-
 core/tx_pool_test.go | 368 ++++++++++++++++++++++++++++++++++++++++++-
 tests/init_test.go   |   3 -
 3 files changed, 371 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index addbc7573c..8550589b77 100644
--- a/Makefile
+++ b/Makefile
@@ -59,7 +59,10 @@ ios:
 	@echo "Import \"$(GOBIN)/Geth.framework\" to use the library."
 
 test:
-	$(GOTEST) --timeout 5m -shuffle=on -cover -coverprofile=cover.out $(TESTALL)
+	$(GOTEST) --timeout 5m -shuffle=on -cover -short -coverprofile=cover.out $(TESTALL)
+
+test-txpool-race:
+	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 180m -race -v ./core/
 
 test-race:
 	$(GOTEST) --timeout 15m -race -shuffle=on $(TESTALL)
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 07903c3480..d63ac07f18 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2751,7 +2751,7 @@ func BenchmarkPoolMining(b *testing.B) {
 			localKeyPub := localKey.PublicKey
 			account := crypto.PubkeyToAddress(localKeyPub)
 
-			balanceStr := "1_000_000_000"
+			const balanceStr = "1_000_000_000"
 			balance, ok := big.NewInt(0).SetString(balanceStr, 0)
 			if !ok {
 				b.Fatal("incorrect initial balance", balanceStr)
@@ -3695,3 +3695,369 @@ func mining(pool *TxPool, signer types.Signer, baseFee *uint256.Int) int {
 
 	return total
 }
+
+//nolint:gocognit,paralleltest
+func TestPoolMiningDataRaces(t *testing.T) {
+	if testing.Short() {
+		t.Skip("only for data race testing")
+	}
+
+	const format = "size %d"
+
+	const blocks = 300
+
+	cases := []struct {
+		name string
+		size int
+	}{
+		{size: 1},
+		{size: 5},
+		{size: 10},
+		{size: 20},
+	}
+
+	for i := range cases {
+		cases[i].name = fmt.Sprintf(format, cases[i].size)
+	}
+
+	//nolint:paralleltest
+	for _, testCase := range cases {
+		singleCase := testCase
+
+		t.Run(singleCase.name, func(t *testing.T) {
+			done := make(chan struct{})
+			defer close(done)
+
+			// Generate a batch of transactions to enqueue into the pool
+			pendingAddedCh := make(chan struct{}, 1024)
+
+			pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
+			defer pool.Stop()
+
+			localKeyPub := localKey.PublicKey
+			account := crypto.PubkeyToAddress(localKeyPub)
+
+			const balanceStr = "1_000_000_000"
+			balance, ok := big.NewInt(0).SetString(balanceStr, 0)
+			if !ok {
+				t.Fatal("incorrect initial balance", balanceStr)
+			}
+
+			testAddBalance(pool, account, balance)
+
+			signer := types.NewEIP155Signer(big.NewInt(1))
+			baseFee := uint256.NewInt(1)
+
+			const batchesSize = 1000
+
+			batchesLocal := make([]types.Transactions, batchesSize)
+			batchesRemote := make([]types.Transactions, batchesSize)
+			batchesRemotes := make([]types.Transactions, batchesSize)
+			batchesRemoteSync := make([]types.Transactions, batchesSize)
+			batchesRemotesSync := make([]types.Transactions, batchesSize)
+
+			for i := 0; i < batchesSize; i++ {
+				batchesLocal[i] = make(types.Transactions, singleCase.size)
+
+				for j := 0; j < singleCase.size; j++ {
+					batchesLocal[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, localKey)
+				}
+
+				batchesRemote[i] = make(types.Transactions, singleCase.size)
+
+				for j := 0; j < singleCase.size; j++ {
+					remoteKey, _ := crypto.GenerateKey()
+					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+					testAddBalance(pool, remoteAddr, balance)
+
+					batchesRemote[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+				}
+
+				batchesRemotes[i] = make(types.Transactions, singleCase.size)
+
+				for j := 0; j < singleCase.size; j++ {
+					remoteKey, _ := crypto.GenerateKey()
+					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+					testAddBalance(pool, remoteAddr, balance)
+
+					batchesRemotes[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+				}
+
+				batchesRemoteSync[i] = make(types.Transactions, singleCase.size)
+
+				for j := 0; j < singleCase.size; j++ {
+					remoteKey, _ := crypto.GenerateKey()
+					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+					testAddBalance(pool, remoteAddr, balance)
+
+					batchesRemoteSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+				}
+
+				batchesRemotesSync[i] = make(types.Transactions, singleCase.size)
+
+				for j := 0; j < singleCase.size; j++ {
+					remoteKey, _ := crypto.GenerateKey()
+					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+					testAddBalance(pool, remoteAddr, balance)
+
+					batchesRemotesSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+				}
+			}
+
+			const timeoutDuration = time.Second
+
+			t.Log("starting goroutines")
+
+			// locals
+			go func() {
+				for _, batch := range batchesLocal {
+					if rand.Int()%2 == 0 {
+						runWithTimeout(t, func(c chan struct{}) {
+							res := pool.AddLocals(batch)
+							fmt.Fprint(io.Discard, res)
+							close(c)
+						}, done, "AddLocals", timeoutDuration)
+					} else {
+						for _, tx := range batch {
+							runWithTimeout(t, func(c chan struct{}) {
+								res := pool.AddLocal(tx)
+								fmt.Fprint(io.Discard, res)
+								close(c)
+							}, done, "AddLocal", timeoutDuration)
+						}
+					}
+				}
+			}()
+
+			// remotes
+			go func() {
+				for _, batch := range batchesRemotes {
+					runWithTimeout(t, func(c chan struct{}) {
+						res := pool.AddRemotes(batch)
+						fmt.Fprint(io.Discard, res)
+						close(c)
+					}, done, "AddRemotes", timeoutDuration)
+				}
+			}()
+
+			// remote
+			go func() {
+				for _, batch := range batchesRemote {
+					for _, tx := range batch {
+						runWithTimeout(t, func(c chan struct{}) {
+							res := pool.AddRemote(tx)
+							fmt.Fprint(io.Discard, res)
+							close(c)
+						}, done, "AddRemote", timeoutDuration)
+					}
+				}
+			}()
+
+			// sync
+			// remotes
+			go func() {
+				for _, batch := range batchesRemotesSync {
+					runWithTimeout(t, func(c chan struct{}) {
+						res := pool.AddRemotesSync(batch)
+						fmt.Fprint(io.Discard, res)
+						close(c)
+					}, done, "AddRemotesSync", timeoutDuration)
+				}
+			}()
+
+			// remote
+			go func() {
+				for _, batch := range batchesRemoteSync {
+					for _, tx := range batch {
+						runWithTimeout(t, func(c chan struct{}) {
+							res := pool.AddRemoteSync(tx)
+							fmt.Fprint(io.Discard, res)
+							close(c)
+						}, done, "AddRemoteSync", timeoutDuration)
+					}
+				}
+			}()
+
+			// tx pool API
+			for i := 0; i < 5; i++ {
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						p := pool.Pending(context.Background(), false)
+						fmt.Fprint(io.Discard, p)
+						close(c)
+					}, done, "Pending-no-tips", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						p := pool.Pending(context.Background(), true)
+						fmt.Fprint(io.Discard, p)
+						close(c)
+					}, done, "Pending-with-tips", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						l := pool.Locals()
+						fmt.Fprint(io.Discard, l)
+						close(c)
+					}, done, "Locals", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						p, q := pool.Content()
+						fmt.Fprint(io.Discard, p, q)
+						close(c)
+					}, done, "Content", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						res := pool.GasPriceUint256()
+						fmt.Fprint(io.Discard, res)
+						close(c)
+					}, done, "GasPriceUint256", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						res := pool.GasPrice()
+						fmt.Fprint(io.Discard, res)
+						close(c)
+					}, done, "GasPrice", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						pool.SetGasPrice(pool.GasPrice())
+						close(c)
+					}, done, "SetGasPrice", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						p, q := pool.ContentFrom(account)
+						fmt.Fprint(io.Discard, p, q)
+						close(c)
+					}, done, "ContentFrom", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						res := pool.Has(batchesRemotes[0][0].Hash())
+						fmt.Fprint(io.Discard, res)
+						close(c)
+					}, done, "Has", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						tx := pool.Get(batchesRemotes[0][0].Hash())
+						fmt.Fprint(io.Discard, tx)
+						close(c)
+					}, done, "Get", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						res := pool.Nonce(account)
+						fmt.Fprint(io.Discard, res)
+						close(c)
+					}, done, "Nonce", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						p, q := pool.Stats()
+						fmt.Fprint(io.Discard, p, q)
+						close(c)
+					}, done, "Stats", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
+						fmt.Fprint(io.Discard, st)
+						close(c)
+					}, done, "Status", timeoutDuration)
+				}()
+
+				go func() {
+					runWithTicker(t, func(c chan struct{}) {
+						ch := make(chan NewTxsEvent, 10)
+						sub := pool.SubscribeNewTxsEvent(ch)
+						res := <-ch
+						fmt.Fprint(io.Discard, res)
+						sub.Unsubscribe()
+						close(c)
+					}, done, "SubscribeNewTxsEvent", timeoutDuration)
+				}()
+			}
+
+			// wait for the start
+			t.Log("before the first propagated transaction")
+			<-pendingAddedCh
+			t.Log("after the first propagated transaction")
+
+			var (
+				totalTxs    int
+				totalBlocks int
+			)
+
+			blockTicker := time.NewTicker(time.Second)
+			defer blockTicker.Stop()
+
+			for range blockTicker.C {
+				totalTxs += mining(pool, signer, baseFee)
+
+				t.Log("block", totalBlocks, "transactions", totalTxs)
+
+				totalBlocks++
+
+				if totalBlocks > blocks {
+					fmt.Fprint(io.Discard, totalTxs)
+					return
+				}
+			}
+		})
+	}
+}
+
+//nolint:unparam
+func runWithTicker(t *testing.T, fn func(c chan struct{}), done chan struct{}, name string, timeoutDuration time.Duration) {
+	t.Helper()
+
+	localTicker := time.NewTimer(100 * time.Millisecond)
+	defer localTicker.Stop()
+
+	for range localTicker.C {
+		select {
+		case <-done:
+			return
+		default:
+		}
+
+		runWithTimeout(t, fn, done, name, timeoutDuration)
+	}
+}
+
+func runWithTimeout(t *testing.T, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration) {
+	t.Helper()
+
+	timeout := time.NewTimer(timeoutDuration)
+	defer timeout.Stop()
+
+	doneCh := make(chan struct{})
+
+	go func() {
+		fn(doneCh)
+	}()
+
+	select {
+	case <-timeout.C:
+		defer close(outerDone)
+		t.Fatalf("%s timeouted", name)
+	case <-doneCh:
+	}
+}
diff --git a/tests/init_test.go b/tests/init_test.go
index 1c6841e030..5e32f20abf 100644
--- a/tests/init_test.go
+++ b/tests/init_test.go
@@ -141,9 +141,6 @@ func (tm *testMatcher) findSkip(name string) (reason string, skipload bool) {
 	isWin32 := runtime.GOARCH == "386" && runtime.GOOS == "windows"
 	for _, re := range tm.slowpat {
 		if re.MatchString(name) {
-			if testing.Short() {
-				return "skipped in -short mode", false
-			}
 			if isWin32 {
 				return "skipped on 32bit windows", false
 			}

From 0acbb6e55c639acac811bad4aedf6938657fcb94 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 08:38:46 +0400
Subject: [PATCH 73/96] fix concurrency

---
 core/tx_pool.go                | 75 ++++++++++++++++++++++++++--------
 core/tx_pool_test.go           |  8 +++-
 core/types/transaction.go      |  8 +---
 core/types/transaction_test.go |  4 +-
 4 files changed, 67 insertions(+), 28 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 529f73a1a8..9970d35748 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -390,9 +390,7 @@ func (pool *TxPool) loop() {
 
 		// Handle stats reporting ticks
 		case <-report.C:
-			pool.mu.RLock()
 			pending, queued := pool.stats()
-			pool.mu.RUnlock()
 			stales := int(atomic.LoadInt64(&pool.priced.stales))
 
 			if pending != prevPending || queued != prevQueued || stales != prevStales {
@@ -532,9 +530,6 @@ func (pool *TxPool) Nonce(addr common.Address) uint64 {
 // Stats retrieves the current pool stats, namely the number of pending and the
 // number of queued (non-executable) transactions.
 func (pool *TxPool) Stats() (int, int) {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
-
 	return pool.stats()
 }
 
@@ -549,20 +544,21 @@ func (pool *TxPool) stats() (int, int) {
 	}
 	pool.pendingMu.RUnlock()
 
+	pool.mu.RLock()
+
 	queued := 0
 	for _, list := range pool.queue {
 		queued += list.Len()
 	}
 
+	pool.mu.RUnlock()
+
 	return pending, queued
 }
 
 // Content retrieves the data content of the transaction pool, returning all the
 // pending as well as queued transactions, grouped by account and sorted by nonce.
 func (pool *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
-
 	pending := make(map[common.Address]types.Transactions)
 
 	pool.pendingMu.RLock()
@@ -572,18 +568,21 @@ func (pool *TxPool) Content() (map[common.Address]types.Transactions, map[common
 	pool.pendingMu.RUnlock()
 
 	queued := make(map[common.Address]types.Transactions)
+
+	pool.mu.RLock()
+
 	for addr, list := range pool.queue {
 		queued[addr] = list.Flatten()
 	}
+
+	pool.mu.RUnlock()
+
 	return pending, queued
 }
 
 // ContentFrom retrieves the data content of the transaction pool, returning the
 // pending as well as queued transactions of this address, grouped by nonce.
 func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.Transactions) {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
-
 	var pending types.Transactions
 
 	pool.pendingMu.RLock()
@@ -592,10 +591,15 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 	}
 	pool.pendingMu.RUnlock()
 
+	pool.mu.RLock()
+
 	var queued types.Transactions
 	if list, ok := pool.queue[addr]; ok {
 		queued = list.Flatten()
 	}
+
+	pool.mu.RUnlock()
+
 	return pending, queued
 }
 
@@ -606,6 +610,8 @@ func (pool *TxPool) ContentFrom(addr common.Address) (types.Transactions, types.
 // The enforceTips parameter can be used to do an extra filtering on the pending
 // transactions and only return those whose **effective** tip is large enough in
 // the next pending execution environment.
+//
+//nolint:gocognit
 func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Address]types.Transactions {
 	pending := make(map[common.Address]types.Transactions, 10)
 
@@ -621,13 +627,30 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 		var pendingTxs int
 
 		tracing.ElapsedTime(ctx, span, "Loop", func(ctx context.Context, s trace.Span) {
+			gasPriceUint := uint256.NewInt(0)
+			baseFee := uint256.NewInt(0)
+
 			for addr, list := range pool.pending {
 				txs := list.Flatten()
 
 				// If the miner requests tip enforcement, cap the lists now
 				if enforceTips && !pool.locals.contains(addr) {
 					for i, tx := range txs {
-						if tx.EffectiveGasTipUintLt(pool.gasPriceUint, pool.priced.urgent.baseFee) {
+						pool.pendingMu.RUnlock()
+
+						pool.mu.RLock()
+						if pool.gasPriceUint != nil {
+							gasPriceUint.Set(pool.gasPriceUint)
+						}
+
+						if pool.priced.urgent.baseFee != nil {
+							baseFee.Set(pool.priced.urgent.baseFee)
+						}
+						pool.mu.RUnlock()
+
+						pool.pendingMu.RLock()
+
+						if tx.EffectiveGasTipUintLt(gasPriceUint, baseFee) {
 							txs = txs[:i]
 							break
 						}
@@ -827,6 +850,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 	from, _ := types.Sender(pool.signer, tx) // already validated
 
 	pool.pendingMu.RLock()
+
 	list := pool.pending[from]
 
 	if list != nil && list.Overlaps(tx) {
@@ -839,6 +863,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err e
 			pendingDiscardMeter.Mark(1)
 			return false, ErrReplaceUnderpriced
 		}
+
 		// New transaction is better, replace old one
 		if old != nil {
 			pool.all.Remove(old.Hash())
@@ -1189,7 +1214,10 @@ func (pool *TxPool) addTxLocked(tx *types.Transaction, local bool) (error, *acco
 func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 	status := make([]TxStatus, len(hashes))
 
-	var txList *txList
+	var (
+		txList    *txList
+		isPending bool
+	)
 
 	for i, hash := range hashes {
 		tx := pool.Get(hash)
@@ -1199,18 +1227,29 @@ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 
 		from, _ := types.Sender(pool.signer, tx) // already validated
 
-		pool.mu.RLock()
 		pool.pendingMu.RLock()
+
 		if txList = pool.pending[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
 			status[i] = TxStatusPending
-		} else if txList := pool.queue[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
-			status[i] = TxStatusQueued
+			isPending = true
+		} else {
+			isPending = false
+		}
+
+		pool.pendingMu.RUnlock()
+
+		if !isPending {
+			pool.mu.RLock()
+
+			if txList := pool.queue[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
+				status[i] = TxStatusQueued
+			}
+
+			pool.mu.RUnlock()
 		}
 
 		// implicit else: the tx may have been included into a block between
 		// checking pool.Get and obtaining the lock. In that case, TxStatusUnknown is correct
-		pool.pendingMu.RUnlock()
-		pool.mu.RUnlock()
 	}
 
 	return status
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index d63ac07f18..57143eb264 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3804,7 +3804,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 				}
 			}
 
-			const timeoutDuration = time.Second
+			const timeoutDuration = 10 * time.Second
 
 			t.Log("starting goroutines")
 
@@ -4056,7 +4056,11 @@ func runWithTimeout(t *testing.T, fn func(chan struct{}), outerDone chan struct{
 
 	select {
 	case <-timeout.C:
-		defer close(outerDone)
+		select {
+		case <-outerDone:
+			close(outerDone)
+		default:
+		}
 		t.Fatalf("%s timeouted", name)
 	case <-doneCh:
 	}
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 8eccfbf691..9b89f12517 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -430,7 +430,7 @@ func (tx *Transaction) EffectiveGasTipUnit(baseFee *uint256.Int) (*uint256.Int,
 
 	var err error
 
-	gasFeeCap := tx.GasFeeCapUint()
+	gasFeeCap := tx.GasFeeCapUint().Clone()
 
 	if gasFeeCap.Lt(baseFee) {
 		err = ErrGasFeeCapTooLow
@@ -454,11 +454,7 @@ func (tx *Transaction) EffectiveGasTipUnit(baseFee *uint256.Int) (*uint256.Int,
 		return gasTipCapUint, err
 	}
 
-	gasFeeCapWithoudBaseFee := gasFeeCap.Clone()
-
-	gasFeeCap.Add(gasFeeCap, baseFee)
-
-	return gasFeeCapWithoudBaseFee, err
+	return gasFeeCap, err
 }
 
 // Hash returns the transaction hash.
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index 9884185260..255a7b76b4 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -364,11 +364,11 @@ func testTransactionPriceNonceSort(t *testing.T, baseFeeBig *big.Int) {
 			nextTipBig, _ := next.EffectiveGasTip(baseFeeBig)
 
 			if tip.Cmp(cmath.FromBig(tipBig)) != 0 {
-				t.Fatalf("EffectiveGasTip incorrect. uint256 %q, big.Int %q", tip.String(), tipBig.String())
+				t.Fatalf("EffectiveGasTip incorrect. uint256 %q, big.Int %q, baseFee %q, baseFeeBig %q", tip.String(), tipBig.String(), baseFee.String(), baseFeeBig.String())
 			}
 
 			if nextTip.Cmp(cmath.FromBig(nextTipBig)) != 0 {
-				t.Fatalf("EffectiveGasTip next incorrect. uint256 %q, big.Int %q", nextTip.String(), nextTipBig.String())
+				t.Fatalf("EffectiveGasTip next incorrect. uint256 %q, big.Int %q, baseFee %q, baseFeeBig %q", nextTip.String(), nextTipBig.String(), baseFee.String(), baseFeeBig.String())
 			}
 
 			if err != nil || nextErr != nil {

From fbaa9688c55e00aca61b975f9ea775b896185713 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 08:46:56 +0400
Subject: [PATCH 74/96] noleak

---
 core/tx_pool_test.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 57143eb264..28ad28ae93 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -34,6 +34,7 @@ import (
 	"time"
 
 	"github.com/holiman/uint256"
+	"go.uber.org/goleak"
 	"gonum.org/v1/gonum/floats"
 	"gonum.org/v1/gonum/stat"
 	"pgregory.net/rapid"
@@ -3725,6 +3726,8 @@ func TestPoolMiningDataRaces(t *testing.T) {
 		singleCase := testCase
 
 		t.Run(singleCase.name, func(t *testing.T) {
+			defer goleak.VerifyNone(t)
+
 			done := make(chan struct{})
 			defer close(done)
 
@@ -3804,7 +3807,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 				}
 			}
 
-			const timeoutDuration = 10 * time.Second
+			const timeoutDuration = 3 * time.Second
 
 			t.Log("starting goroutines")
 

From ae7e72d2903198bb3efbb98b46cbfbffa94f93ca Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 08:56:22 +0400
Subject: [PATCH 75/96] increase batch size

---
 core/tx_pool_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 28ad28ae93..1961c7be59 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3751,7 +3751,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 			signer := types.NewEIP155Signer(big.NewInt(1))
 			baseFee := uint256.NewInt(1)
 
-			const batchesSize = 1000
+			const batchesSize = 10_000
 
 			batchesLocal := make([]types.Transactions, batchesSize)
 			batchesRemote := make([]types.Transactions, batchesSize)

From 54950ff1b7c631c04c46e4b8c2b665efa200bb6a Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 09:14:39 +0400
Subject: [PATCH 76/96] prettify

---
 core/tx_pool_test.go | 530 ++++++++++++++++++++++---------------------
 1 file changed, 271 insertions(+), 259 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 1961c7be59..d35f02519c 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3697,7 +3697,7 @@ func mining(pool *TxPool, signer types.Signer, baseFee *uint256.Int) int {
 	return total
 }
 
-//nolint:gocognit,paralleltest
+//nolint:paralleltest
 func TestPoolMiningDataRaces(t *testing.T) {
 	if testing.Short() {
 		t.Skip("only for data race testing")
@@ -3705,8 +3705,6 @@ func TestPoolMiningDataRaces(t *testing.T) {
 
 	const format = "size %d"
 
-	const blocks = 300
-
 	cases := []struct {
 		name string
 		size int
@@ -3728,310 +3726,324 @@ func TestPoolMiningDataRaces(t *testing.T) {
 		t.Run(singleCase.name, func(t *testing.T) {
 			defer goleak.VerifyNone(t)
 
-			done := make(chan struct{})
-			defer close(done)
+			const (
+				blocks          = 300
+				blockPeriod     = time.Second
+				threads         = 10
+				batchesSize     = 10_000
+				timeoutDuration = 3 * time.Second
+				tickerDuration  = 5 * time.Millisecond
 
-			// Generate a batch of transactions to enqueue into the pool
-			pendingAddedCh := make(chan struct{}, 1024)
+				balanceStr = "1_000_000_000"
+			)
 
-			pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
-			defer pool.Stop()
+			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, tickerDuration, blockPeriod, blocks)
+		})
+	}
+}
 
-			localKeyPub := localKey.PublicKey
-			account := crypto.PubkeyToAddress(localKeyPub)
+//nolint:gocognit,thelper
+func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase struct {
+	name string
+	size int
+}, timeoutDuration time.Duration, threads int, tickerDuration time.Duration, blockPeriod time.Duration, blocks int) {
+	done := make(chan struct{})
+	defer close(done)
 
-			const balanceStr = "1_000_000_000"
-			balance, ok := big.NewInt(0).SetString(balanceStr, 0)
-			if !ok {
-				t.Fatal("incorrect initial balance", balanceStr)
-			}
+	// Generate a batch of transactions to enqueue into the pool
+	pendingAddedCh := make(chan struct{}, 1024)
 
-			testAddBalance(pool, account, balance)
+	pool, localKey := setupTxPoolWithConfig(params.TestChainConfig, testTxPoolConfig, txPoolGasLimit, MakeWithPromoteTxCh(pendingAddedCh))
+	defer pool.Stop()
 
-			signer := types.NewEIP155Signer(big.NewInt(1))
-			baseFee := uint256.NewInt(1)
+	localKeyPub := localKey.PublicKey
+	account := crypto.PubkeyToAddress(localKeyPub)
 
-			const batchesSize = 10_000
+	balance, ok := big.NewInt(0).SetString(balanceStr, 0)
+	if !ok {
+		t.Fatal("incorrect initial balance", balanceStr)
+	}
 
-			batchesLocal := make([]types.Transactions, batchesSize)
-			batchesRemote := make([]types.Transactions, batchesSize)
-			batchesRemotes := make([]types.Transactions, batchesSize)
-			batchesRemoteSync := make([]types.Transactions, batchesSize)
-			batchesRemotesSync := make([]types.Transactions, batchesSize)
+	testAddBalance(pool, account, balance)
 
-			for i := 0; i < batchesSize; i++ {
-				batchesLocal[i] = make(types.Transactions, singleCase.size)
+	signer := types.NewEIP155Signer(big.NewInt(1))
+	baseFee := uint256.NewInt(1)
 
-				for j := 0; j < singleCase.size; j++ {
-					batchesLocal[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, localKey)
-				}
+	batchesLocal := make([]types.Transactions, batchesSize)
+	batchesRemote := make([]types.Transactions, batchesSize)
+	batchesRemotes := make([]types.Transactions, batchesSize)
+	batchesRemoteSync := make([]types.Transactions, batchesSize)
+	batchesRemotesSync := make([]types.Transactions, batchesSize)
 
-				batchesRemote[i] = make(types.Transactions, singleCase.size)
+	for i := 0; i < batchesSize; i++ {
+		batchesLocal[i] = make(types.Transactions, singleCase.size)
 
-				for j := 0; j < singleCase.size; j++ {
-					remoteKey, _ := crypto.GenerateKey()
-					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-					testAddBalance(pool, remoteAddr, balance)
+		for j := 0; j < singleCase.size; j++ {
+			batchesLocal[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, localKey)
+		}
 
-					batchesRemote[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
-				}
+		batchesRemote[i] = make(types.Transactions, singleCase.size)
 
-				batchesRemotes[i] = make(types.Transactions, singleCase.size)
+		for j := 0; j < singleCase.size; j++ {
+			remoteKey, _ := crypto.GenerateKey()
+			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+			testAddBalance(pool, remoteAddr, balance)
 
-				for j := 0; j < singleCase.size; j++ {
-					remoteKey, _ := crypto.GenerateKey()
-					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-					testAddBalance(pool, remoteAddr, balance)
+			batchesRemote[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		}
 
-					batchesRemotes[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
-				}
+		batchesRemotes[i] = make(types.Transactions, singleCase.size)
 
-				batchesRemoteSync[i] = make(types.Transactions, singleCase.size)
+		for j := 0; j < singleCase.size; j++ {
+			remoteKey, _ := crypto.GenerateKey()
+			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+			testAddBalance(pool, remoteAddr, balance)
 
-				for j := 0; j < singleCase.size; j++ {
-					remoteKey, _ := crypto.GenerateKey()
-					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-					testAddBalance(pool, remoteAddr, balance)
+			batchesRemotes[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		}
 
-					batchesRemoteSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
-				}
+		batchesRemoteSync[i] = make(types.Transactions, singleCase.size)
 
-				batchesRemotesSync[i] = make(types.Transactions, singleCase.size)
+		for j := 0; j < singleCase.size; j++ {
+			remoteKey, _ := crypto.GenerateKey()
+			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+			testAddBalance(pool, remoteAddr, balance)
 
-				for j := 0; j < singleCase.size; j++ {
-					remoteKey, _ := crypto.GenerateKey()
-					remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-					testAddBalance(pool, remoteAddr, balance)
+			batchesRemoteSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		}
 
-					batchesRemotesSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
-				}
-			}
+		batchesRemotesSync[i] = make(types.Transactions, singleCase.size)
 
-			const timeoutDuration = 3 * time.Second
+		for j := 0; j < singleCase.size; j++ {
+			remoteKey, _ := crypto.GenerateKey()
+			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+			testAddBalance(pool, remoteAddr, balance)
 
-			t.Log("starting goroutines")
+			batchesRemotesSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		}
+	}
 
-			// locals
-			go func() {
-				for _, batch := range batchesLocal {
-					if rand.Int()%2 == 0 {
-						runWithTimeout(t, func(c chan struct{}) {
-							res := pool.AddLocals(batch)
-							fmt.Fprint(io.Discard, res)
-							close(c)
-						}, done, "AddLocals", timeoutDuration)
-					} else {
-						for _, tx := range batch {
-							runWithTimeout(t, func(c chan struct{}) {
-								res := pool.AddLocal(tx)
-								fmt.Fprint(io.Discard, res)
-								close(c)
-							}, done, "AddLocal", timeoutDuration)
-						}
-					}
-				}
-			}()
+	t.Log("starting goroutines")
 
-			// remotes
-			go func() {
-				for _, batch := range batchesRemotes {
-					runWithTimeout(t, func(c chan struct{}) {
-						res := pool.AddRemotes(batch)
-						fmt.Fprint(io.Discard, res)
-						close(c)
-					}, done, "AddRemotes", timeoutDuration)
-				}
-			}()
-
-			// remote
-			go func() {
-				for _, batch := range batchesRemote {
-					for _, tx := range batch {
-						runWithTimeout(t, func(c chan struct{}) {
-							res := pool.AddRemote(tx)
-							fmt.Fprint(io.Discard, res)
-							close(c)
-						}, done, "AddRemote", timeoutDuration)
-					}
-				}
-			}()
-
-			// sync
-			// remotes
-			go func() {
-				for _, batch := range batchesRemotesSync {
+	// locals
+	go func() {
+		for _, batch := range batchesLocal {
+			if rand.Int()%2 == 0 {
+				runWithTimeout(t, func(c chan struct{}) {
+					res := pool.AddLocals(batch)
+					fmt.Fprint(io.Discard, res)
+					close(c)
+				}, done, "AddLocals", timeoutDuration)
+			} else {
+				for _, tx := range batch {
 					runWithTimeout(t, func(c chan struct{}) {
-						res := pool.AddRemotesSync(batch)
+						res := pool.AddLocal(tx)
 						fmt.Fprint(io.Discard, res)
 						close(c)
-					}, done, "AddRemotesSync", timeoutDuration)
-				}
-			}()
-
-			// remote
-			go func() {
-				for _, batch := range batchesRemoteSync {
-					for _, tx := range batch {
-						runWithTimeout(t, func(c chan struct{}) {
-							res := pool.AddRemoteSync(tx)
-							fmt.Fprint(io.Discard, res)
-							close(c)
-						}, done, "AddRemoteSync", timeoutDuration)
-					}
+					}, done, "AddLocal", timeoutDuration)
 				}
-			}()
-
-			// tx pool API
-			for i := 0; i < 5; i++ {
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						p := pool.Pending(context.Background(), false)
-						fmt.Fprint(io.Discard, p)
-						close(c)
-					}, done, "Pending-no-tips", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						p := pool.Pending(context.Background(), true)
-						fmt.Fprint(io.Discard, p)
-						close(c)
-					}, done, "Pending-with-tips", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						l := pool.Locals()
-						fmt.Fprint(io.Discard, l)
-						close(c)
-					}, done, "Locals", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						p, q := pool.Content()
-						fmt.Fprint(io.Discard, p, q)
-						close(c)
-					}, done, "Content", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						res := pool.GasPriceUint256()
-						fmt.Fprint(io.Discard, res)
-						close(c)
-					}, done, "GasPriceUint256", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						res := pool.GasPrice()
-						fmt.Fprint(io.Discard, res)
-						close(c)
-					}, done, "GasPrice", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						pool.SetGasPrice(pool.GasPrice())
-						close(c)
-					}, done, "SetGasPrice", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						p, q := pool.ContentFrom(account)
-						fmt.Fprint(io.Discard, p, q)
-						close(c)
-					}, done, "ContentFrom", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						res := pool.Has(batchesRemotes[0][0].Hash())
-						fmt.Fprint(io.Discard, res)
-						close(c)
-					}, done, "Has", timeoutDuration)
-				}()
-
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						tx := pool.Get(batchesRemotes[0][0].Hash())
-						fmt.Fprint(io.Discard, tx)
-						close(c)
-					}, done, "Get", timeoutDuration)
-				}()
+			}
+		}
+	}()
 
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						res := pool.Nonce(account)
-						fmt.Fprint(io.Discard, res)
-						close(c)
-					}, done, "Nonce", timeoutDuration)
-				}()
+	// remotes
+	go func() {
+		for _, batch := range batchesRemotes {
+			runWithTimeout(t, func(c chan struct{}) {
+				res := pool.AddRemotes(batch)
+				fmt.Fprint(io.Discard, res)
+				close(c)
+			}, done, "AddRemotes", timeoutDuration)
+		}
+	}()
 
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						p, q := pool.Stats()
-						fmt.Fprint(io.Discard, p, q)
-						close(c)
-					}, done, "Stats", timeoutDuration)
-				}()
+	// remote
+	go func() {
+		for _, batch := range batchesRemote {
+			for _, tx := range batch {
+				runWithTimeout(t, func(c chan struct{}) {
+					res := pool.AddRemote(tx)
+					fmt.Fprint(io.Discard, res)
+					close(c)
+				}, done, "AddRemote", timeoutDuration)
+			}
+		}
+	}()
 
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
-						fmt.Fprint(io.Discard, st)
-						close(c)
-					}, done, "Status", timeoutDuration)
-				}()
+	// sync
+	// remotes
+	go func() {
+		for _, batch := range batchesRemotesSync {
+			runWithTimeout(t, func(c chan struct{}) {
+				res := pool.AddRemotesSync(batch)
+				fmt.Fprint(io.Discard, res)
+				close(c)
+			}, done, "AddRemotesSync", timeoutDuration)
+		}
+	}()
 
-				go func() {
-					runWithTicker(t, func(c chan struct{}) {
-						ch := make(chan NewTxsEvent, 10)
-						sub := pool.SubscribeNewTxsEvent(ch)
-						res := <-ch
-						fmt.Fprint(io.Discard, res)
-						sub.Unsubscribe()
-						close(c)
-					}, done, "SubscribeNewTxsEvent", timeoutDuration)
-				}()
+	// remote
+	go func() {
+		for _, batch := range batchesRemoteSync {
+			for _, tx := range batch {
+				runWithTimeout(t, func(c chan struct{}) {
+					res := pool.AddRemoteSync(tx)
+					fmt.Fprint(io.Discard, res)
+					close(c)
+				}, done, "AddRemoteSync", timeoutDuration)
 			}
+		}
+	}()
 
-			// wait for the start
-			t.Log("before the first propagated transaction")
-			<-pendingAddedCh
-			t.Log("after the first propagated transaction")
+	// tx pool API
+	for i := 0; i < threads; i++ {
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				p := pool.Pending(context.Background(), false)
+				fmt.Fprint(io.Discard, p)
+				close(c)
+			}, done, "Pending-no-tips", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				p := pool.Pending(context.Background(), true)
+				fmt.Fprint(io.Discard, p)
+				close(c)
+			}, done, "Pending-with-tips", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				l := pool.Locals()
+				fmt.Fprint(io.Discard, l)
+				close(c)
+			}, done, "Locals", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				p, q := pool.Content()
+				fmt.Fprint(io.Discard, p, q)
+				close(c)
+			}, done, "Content", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				res := pool.GasPriceUint256()
+				fmt.Fprint(io.Discard, res)
+				close(c)
+			}, done, "GasPriceUint256", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				res := pool.GasPrice()
+				fmt.Fprint(io.Discard, res)
+				close(c)
+			}, done, "GasPrice", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				pool.SetGasPrice(pool.GasPrice())
+				close(c)
+			}, done, "SetGasPrice", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				p, q := pool.ContentFrom(account)
+				fmt.Fprint(io.Discard, p, q)
+				close(c)
+			}, done, "ContentFrom", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				res := pool.Has(batchesRemotes[0][0].Hash())
+				fmt.Fprint(io.Discard, res)
+				close(c)
+			}, done, "Has", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				tx := pool.Get(batchesRemotes[0][0].Hash())
+				fmt.Fprint(io.Discard, tx)
+				close(c)
+			}, done, "Get", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				res := pool.Nonce(account)
+				fmt.Fprint(io.Discard, res)
+				close(c)
+			}, done, "Nonce", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				p, q := pool.Stats()
+				fmt.Fprint(io.Discard, p, q)
+				close(c)
+			}, done, "Stats", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
+				fmt.Fprint(io.Discard, st)
+				close(c)
+			}, done, "Status", tickerDuration, timeoutDuration)
+		}()
+
+		go func() {
+			runWithTicker(t, func(c chan struct{}) {
+				ch := make(chan NewTxsEvent, 10)
+				sub := pool.SubscribeNewTxsEvent(ch)
+				res := <-ch
+				fmt.Fprint(io.Discard, res)
+				sub.Unsubscribe()
+				close(c)
+			}, done, "SubscribeNewTxsEvent", tickerDuration, timeoutDuration)
+		}()
+	}
+
+	// wait for the start
+	t.Log("before the first propagated transaction")
+	<-pendingAddedCh
+	t.Log("after the first propagated transaction")
 
-			var (
-				totalTxs    int
-				totalBlocks int
-			)
+	var (
+		totalTxs    int
+		totalBlocks int
+	)
 
-			blockTicker := time.NewTicker(time.Second)
-			defer blockTicker.Stop()
+	blockTicker := time.NewTicker(blockPeriod)
+	defer blockTicker.Stop()
 
-			for range blockTicker.C {
-				totalTxs += mining(pool, signer, baseFee)
+	for range blockTicker.C {
+		totalTxs += mining(pool, signer, baseFee)
 
-				t.Log("block", totalBlocks, "transactions", totalTxs)
+		t.Log("block", totalBlocks, "transactions", totalTxs)
 
-				totalBlocks++
+		totalBlocks++
 
-				if totalBlocks > blocks {
-					fmt.Fprint(io.Discard, totalTxs)
-					return
-				}
-			}
-		})
+		if totalBlocks > blocks {
+			fmt.Fprint(io.Discard, totalTxs)
+			return
+		}
 	}
 }
 
 //nolint:unparam
-func runWithTicker(t *testing.T, fn func(c chan struct{}), done chan struct{}, name string, timeoutDuration time.Duration) {
+func runWithTicker(t *testing.T, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration) {
 	t.Helper()
 
-	localTicker := time.NewTimer(100 * time.Millisecond)
+	localTicker := time.NewTimer(tickerDuration)
 	defer localTicker.Stop()
 
 	for range localTicker.C {

From 9bb0be447574af24ec6f06cd784f97a9fd108507 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 10:11:22 +0400
Subject: [PATCH 77/96] tests

---
 core/tx_pool_test.go | 97 ++++++++++++++++++++++----------------------
 1 file changed, 48 insertions(+), 49 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index d35f02519c..5e5b311a72 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -40,6 +40,7 @@ import (
 	"pgregory.net/rapid"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/leak"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -3724,10 +3725,10 @@ func TestPoolMiningDataRaces(t *testing.T) {
 		singleCase := testCase
 
 		t.Run(singleCase.name, func(t *testing.T) {
-			defer goleak.VerifyNone(t)
+			defer goleak.VerifyNone(t, leak.IgnoreList()...)
 
 			const (
-				blocks          = 300
+				blocks          = 600
 				blockPeriod     = time.Second
 				threads         = 10
 				batchesSize     = 10_000
@@ -3829,31 +3830,34 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesLocal {
 			if rand.Int()%2 == 0 {
-				runWithTimeout(t, func(c chan struct{}) {
+				runWithTimeout(t, func(_ chan struct{}) {
 					res := pool.AddLocals(batch)
 					fmt.Fprint(io.Discard, res)
-					close(c)
 				}, done, "AddLocals", timeoutDuration)
 			} else {
 				for _, tx := range batch {
-					runWithTimeout(t, func(c chan struct{}) {
+					runWithTimeout(t, func(_ chan struct{}) {
 						res := pool.AddLocal(tx)
 						fmt.Fprint(io.Discard, res)
-						close(c)
 					}, done, "AddLocal", timeoutDuration)
+
+					time.Sleep(tickerDuration)
 				}
 			}
+
+			time.Sleep(tickerDuration)
 		}
 	}()
 
 	// remotes
 	go func() {
 		for _, batch := range batchesRemotes {
-			runWithTimeout(t, func(c chan struct{}) {
+			runWithTimeout(t, func(_ chan struct{}) {
 				res := pool.AddRemotes(batch)
 				fmt.Fprint(io.Discard, res)
-				close(c)
 			}, done, "AddRemotes", timeoutDuration)
+
+			time.Sleep(tickerDuration)
 		}
 	}()
 
@@ -3861,12 +3865,15 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesRemote {
 			for _, tx := range batch {
-				runWithTimeout(t, func(c chan struct{}) {
+				runWithTimeout(t, func(_ chan struct{}) {
 					res := pool.AddRemote(tx)
 					fmt.Fprint(io.Discard, res)
-					close(c)
 				}, done, "AddRemote", timeoutDuration)
+
+				time.Sleep(tickerDuration)
 			}
+
+			time.Sleep(tickerDuration)
 		}
 	}()
 
@@ -3874,11 +3881,12 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	// remotes
 	go func() {
 		for _, batch := range batchesRemotesSync {
-			runWithTimeout(t, func(c chan struct{}) {
+			runWithTimeout(t, func(_ chan struct{}) {
 				res := pool.AddRemotesSync(batch)
 				fmt.Fprint(io.Discard, res)
-				close(c)
 			}, done, "AddRemotesSync", timeoutDuration)
+
+			time.Sleep(tickerDuration)
 		}
 	}()
 
@@ -3886,117 +3894,107 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesRemoteSync {
 			for _, tx := range batch {
-				runWithTimeout(t, func(c chan struct{}) {
+				runWithTimeout(t, func(_ chan struct{}) {
 					res := pool.AddRemoteSync(tx)
 					fmt.Fprint(io.Discard, res)
-					close(c)
 				}, done, "AddRemoteSync", timeoutDuration)
+
+				time.Sleep(tickerDuration)
 			}
+
+			time.Sleep(tickerDuration)
 		}
 	}()
 
 	// tx pool API
 	for i := 0; i < threads; i++ {
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), false)
 				fmt.Fprint(io.Discard, p)
-				close(c)
 			}, done, "Pending-no-tips", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), true)
 				fmt.Fprint(io.Discard, p)
-				close(c)
 			}, done, "Pending-with-tips", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				l := pool.Locals()
 				fmt.Fprint(io.Discard, l)
-				close(c)
 			}, done, "Locals", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				p, q := pool.Content()
 				fmt.Fprint(io.Discard, p, q)
-				close(c)
 			}, done, "Content", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				res := pool.GasPriceUint256()
 				fmt.Fprint(io.Discard, res)
-				close(c)
 			}, done, "GasPriceUint256", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				res := pool.GasPrice()
 				fmt.Fprint(io.Discard, res)
-				close(c)
 			}, done, "GasPrice", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				pool.SetGasPrice(pool.GasPrice())
-				close(c)
 			}, done, "SetGasPrice", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				p, q := pool.ContentFrom(account)
 				fmt.Fprint(io.Discard, p, q)
-				close(c)
 			}, done, "ContentFrom", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				res := pool.Has(batchesRemotes[0][0].Hash())
 				fmt.Fprint(io.Discard, res)
-				close(c)
 			}, done, "Has", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				tx := pool.Get(batchesRemotes[0][0].Hash())
-				fmt.Fprint(io.Discard, tx)
-				close(c)
+				fmt.Fprint(io.Discard, tx.Hash())
 			}, done, "Get", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				res := pool.Nonce(account)
 				fmt.Fprint(io.Discard, res)
-				close(c)
 			}, done, "Nonce", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				p, q := pool.Stats()
 				fmt.Fprint(io.Discard, p, q)
-				close(c)
 			}, done, "Stats", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(t, func(_ chan struct{}) {
 				st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
 				fmt.Fprint(io.Discard, st)
-				close(c)
 			}, done, "Status", tickerDuration, timeoutDuration)
 		}()
 
@@ -4004,10 +4002,14 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 			runWithTicker(t, func(c chan struct{}) {
 				ch := make(chan NewTxsEvent, 10)
 				sub := pool.SubscribeNewTxsEvent(ch)
-				res := <-ch
-				fmt.Fprint(io.Discard, res)
+
+				select {
+				case <-c:
+				case res := <-ch:
+					fmt.Fprint(io.Discard, res)
+				}
+
 				sub.Unsubscribe()
-				close(c)
 			}, done, "SubscribeNewTxsEvent", tickerDuration, timeoutDuration)
 		}()
 	}
@@ -4064,6 +4066,7 @@ func runWithTimeout(t *testing.T, fn func(chan struct{}), outerDone chan struct{
 	defer timeout.Stop()
 
 	doneCh := make(chan struct{})
+	defer close(doneCh)
 
 	go func() {
 		fn(doneCh)
@@ -4071,12 +4074,8 @@ func runWithTimeout(t *testing.T, fn func(chan struct{}), outerDone chan struct{
 
 	select {
 	case <-timeout.C:
-		select {
-		case <-outerDone:
-			close(outerDone)
-		default:
-		}
 		t.Fatalf("%s timeouted", name)
+	case <-outerDone:
 	case <-doneCh:
 	}
 }

From cec80de3b9f22ae67f087d6138cedbdc6f38d56d Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 16:26:55 +0400
Subject: [PATCH 78/96] baseFee mutex

---
 core/tx_list.go      |  14 ++++-
 core/tx_pool.go      |  32 +++++++----
 core/tx_pool_test.go | 127 +++++++++++++++++++++++++++----------------
 3 files changed, 112 insertions(+), 61 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index a68d0cc054..83d9a8faf6 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -524,8 +524,9 @@ func (l *txList) LastElement() *types.Transaction {
 // then the heap is sorted based on the effective tip based on the given base fee.
 // If baseFee is nil then the sorting is based on gasFeeCap.
 type priceHeap struct {
-	baseFee *uint256.Int // heap should always be re-sorted after baseFee is changed
-	list    []*types.Transaction
+	baseFee   *uint256.Int // heap should always be re-sorted after baseFee is changed
+	list      []*types.Transaction
+	baseFeeMu sync.RWMutex
 }
 
 func (h *priceHeap) Len() int      { return len(h.list) }
@@ -543,13 +544,19 @@ func (h *priceHeap) Less(i, j int) bool {
 }
 
 func (h *priceHeap) cmp(a, b *types.Transaction) int {
+	h.baseFeeMu.RLock()
+
 	if h.baseFee != nil {
 		// Compare effective tips if baseFee is specified
 		if c := a.EffectiveGasTipTxUintCmp(b, h.baseFee); c != 0 {
+			h.baseFeeMu.RUnlock()
+
 			return c
 		}
 	}
 
+	h.baseFeeMu.RUnlock()
+
 	// Compare fee caps if baseFee is not specified or effective tips are equal
 	if c := a.GasFeeCapCmp(b); c != 0 {
 		return c
@@ -735,6 +742,9 @@ func (l *txPricedList) Reheap() {
 // SetBaseFee updates the base fee and triggers a re-heap. Note that Removed is not
 // necessary to call right before SetBaseFee when processing a new block.
 func (l *txPricedList) SetBaseFee(baseFee *uint256.Int) {
+	l.urgent.baseFeeMu.Lock()
 	l.urgent.baseFee = baseFee
+	l.urgent.baseFeeMu.Unlock()
+
 	l.Reheap()
 }
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 9970d35748..47ff14ae0f 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -246,10 +246,12 @@ type TxPool struct {
 	chain        blockChain
 	gasPrice     *big.Int
 	gasPriceUint *uint256.Int
-	txFeed       event.Feed
-	scope        event.SubscriptionScope
-	signer       types.Signer
-	mu           sync.RWMutex
+	gasPriceMu   sync.RWMutex
+
+	txFeed event.Feed
+	scope  event.SubscriptionScope
+	signer types.Signer
+	mu     sync.RWMutex
 
 	istanbul bool // Fork indicator whether we are in the istanbul stage.
 	eip2718  bool // Fork indicator whether we are using EIP-2718 type transactions.
@@ -476,15 +478,15 @@ func (pool *TxPool) SubscribeNewTxsEvent(ch chan<- NewTxsEvent) event.Subscripti
 
 // GasPrice returns the current gas price enforced by the transaction pool.
 func (pool *TxPool) GasPrice() *big.Int {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
+	pool.gasPriceMu.RLock()
+	defer pool.gasPriceMu.RUnlock()
 
 	return new(big.Int).Set(pool.gasPrice)
 }
 
 func (pool *TxPool) GasPriceUint256() *uint256.Int {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
+	pool.gasPriceMu.RLock()
+	defer pool.gasPriceMu.RUnlock()
 
 	return pool.gasPriceUint.Clone()
 }
@@ -492,8 +494,8 @@ func (pool *TxPool) GasPriceUint256() *uint256.Int {
 // SetGasPrice updates the minimum price required by the transaction pool for a
 // new transaction, and drops all transactions below this threshold.
 func (pool *TxPool) SetGasPrice(price *big.Int) {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
+	pool.gasPriceMu.Lock()
+	defer pool.gasPriceMu.Unlock()
 
 	old := pool.gasPrice
 	pool.gasPrice = price
@@ -506,6 +508,9 @@ func (pool *TxPool) SetGasPrice(price *big.Int) {
 
 	// if the min miner fee increased, remove transactions below the new threshold
 	if price.Cmp(old) > 0 {
+		pool.mu.Lock()
+		defer pool.mu.Unlock()
+
 		// pool.priced is sorted by GasFeeCap, so we have to iterate through pool.all instead
 		drop := pool.all.RemotesBelowTip(price)
 		for _, tx := range drop {
@@ -638,15 +643,18 @@ func (pool *TxPool) Pending(ctx context.Context, enforceTips bool) map[common.Ad
 					for i, tx := range txs {
 						pool.pendingMu.RUnlock()
 
-						pool.mu.RLock()
+						pool.gasPriceMu.RLock()
 						if pool.gasPriceUint != nil {
 							gasPriceUint.Set(pool.gasPriceUint)
 						}
 
+						pool.priced.urgent.baseFeeMu.Lock()
 						if pool.priced.urgent.baseFee != nil {
 							baseFee.Set(pool.priced.urgent.baseFee)
 						}
-						pool.mu.RUnlock()
+						pool.priced.urgent.baseFeeMu.Unlock()
+
+						pool.gasPriceMu.RUnlock()
 
 						pool.pendingMu.RLock()
 
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 5e5b311a72..c2ad8a340d 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -102,7 +102,7 @@ func transaction(nonce uint64, gaslimit uint64, key *ecdsa.PrivateKey) *types.Tr
 }
 
 func pricedTransaction(nonce uint64, gaslimit uint64, gasprice *big.Int, key *ecdsa.PrivateKey) *types.Transaction {
-	tx, _ := types.SignTx(types.NewTransaction(nonce, common.Address{}, big.NewInt(100), gaslimit, gasprice, nil), types.HomesteadSigner{}, key)
+	tx, _ := types.SignTx(types.NewTransaction(nonce, common.Address{0x01}, big.NewInt(100), gaslimit, gasprice, nil), types.HomesteadSigner{}, key)
 	return tx
 }
 
@@ -336,8 +336,10 @@ func TestInvalidTransactions(t *testing.T) {
 	}
 
 	tx = transaction(1, 100000, key)
+	pool.gasPriceMu.Lock()
 	pool.gasPrice = big.NewInt(1000)
 	pool.gasPriceUint = uint256.NewInt(1000)
+	pool.gasPriceMu.Unlock()
 
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
 		t.Error("expected", ErrUnderpriced, "got", err)
@@ -2738,6 +2740,8 @@ func BenchmarkPoolMining(b *testing.B) {
 		cases[i].name = fmt.Sprintf(format, cases[i].size)
 	}
 
+	const blockGasLimit = 30_000_000
+
 	// Benchmark importing the transactions into the queue
 
 	for _, testCase := range cases {
@@ -2796,7 +2800,7 @@ func BenchmarkPoolMining(b *testing.B) {
 			b.ReportAllocs()
 
 			for i := 0; i < b.N; i++ {
-				total += mining(pool, signer, baseFee)
+				total += mining(b, pool, signer, baseFee, blockGasLimit, i)
 			}
 
 			b.StopTimer()
@@ -3491,7 +3495,7 @@ func testPoolBatchInsert(t *testing.T, cfg txPoolRapidConfig) {
 
 					// check if txPool got stuck
 					if currentTxPoolStats == lastTxPoolStats {
-						stuckBlocks++ //todo: переписать
+						stuckBlocks++ //todo: need something better then that
 					} else {
 						stuckBlocks = 0
 						lastTxPoolStats = currentTxPoolStats
@@ -3644,7 +3648,10 @@ func commitTransactions(pool *TxPool, txs *types.TransactionsByPriceAndNonce, bl
 
 		if tx.Gas() <= blockGasLimit {
 			blockGasLimit -= tx.Gas()
+
+			pool.mu.Lock()
 			pool.removeTx(tx.Hash(), false)
+			pool.mu.Unlock()
 
 			txCount++
 		} else {
@@ -3660,7 +3667,7 @@ func MakeWithPromoteTxCh(ch chan struct{}) func(*TxPool) {
 	}
 }
 
-func mining(pool *TxPool, signer types.Signer, baseFee *uint256.Int) int {
+func mining(t testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) int {
 	var (
 		localTxsCount  int
 		remoteTxsCount int
@@ -3672,7 +3679,11 @@ func mining(pool *TxPool, signer types.Signer, baseFee *uint256.Int) int {
 	pending := pool.Pending(context.Background(), true)
 	remoteTxs = pending
 
-	for _, account := range pool.Locals() {
+	locals := pool.Locals()
+
+	pendingLen, queuedLen := pool.Stats()
+
+	for _, account := range locals {
 		if txs := remoteTxs[account]; len(txs) > 0 {
 			delete(remoteTxs, account)
 
@@ -3683,18 +3694,29 @@ func mining(pool *TxPool, signer types.Signer, baseFee *uint256.Int) int {
 	localTxsCount = len(localTxs)
 	remoteTxsCount = len(remoteTxs)
 
+	var txLocalCount int
+
 	if localTxsCount > 0 {
 		txs := types.NewTransactionsByPriceAndNonce(signer, localTxs, baseFee)
 
-		total += txs.GetTxs()
+		blockGasLimit, txLocalCount = commitTransactions(pool, txs, blockGasLimit)
+
+		total += txLocalCount
 	}
 
+	var txRemoteCount int
+
 	if remoteTxsCount > 0 {
 		txs := types.NewTransactionsByPriceAndNonce(signer, remoteTxs, baseFee)
 
-		total += txs.GetTxs()
+		_, txRemoteCount = commitTransactions(pool, txs, blockGasLimit)
+
+		total += txRemoteCount
 	}
 
+	t.Logf("mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d",
+		totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen)
+
 	return total
 }
 
@@ -3710,7 +3732,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 		name string
 		size int
 	}{
-		{size: 1},
+		{size: 5},
 		{size: 5},
 		{size: 10},
 		{size: 20},
@@ -3729,6 +3751,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 
 			const (
 				blocks          = 600
+				blockGasLimit   = 40_000_000
 				blockPeriod     = time.Second
 				threads         = 10
 				batchesSize     = 10_000
@@ -3738,16 +3761,16 @@ func TestPoolMiningDataRaces(t *testing.T) {
 				balanceStr = "1_000_000_000"
 			)
 
-			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, tickerDuration, blockPeriod, blocks)
+			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, tickerDuration, blockPeriod, blocks, blockGasLimit)
 		})
 	}
 }
 
 //nolint:gocognit,thelper
-func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase struct {
+func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase struct {
 	name string
 	size int
-}, timeoutDuration time.Duration, threads int, tickerDuration time.Duration, blockPeriod time.Duration, blocks int) {
+}, timeoutDuration time.Duration, threads int, tickerDuration time.Duration, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
 	done := make(chan struct{})
 	defer close(done)
 
@@ -3785,42 +3808,42 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 
 		batchesRemote[i] = make(types.Transactions, singleCase.size)
 
-		for j := 0; j < singleCase.size; j++ {
-			remoteKey, _ := crypto.GenerateKey()
-			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-			testAddBalance(pool, remoteAddr, balance)
+		remoteKey, _ := crypto.GenerateKey()
+		remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
+		testAddBalance(pool, remoteAddr, balance)
 
+		for j := 0; j < singleCase.size; j++ {
 			batchesRemote[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
 		}
 
 		batchesRemotes[i] = make(types.Transactions, singleCase.size)
 
-		for j := 0; j < singleCase.size; j++ {
-			remoteKey, _ := crypto.GenerateKey()
-			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-			testAddBalance(pool, remoteAddr, balance)
+		remotesKey, _ := crypto.GenerateKey()
+		remotesAddr := crypto.PubkeyToAddress(remotesKey.PublicKey)
+		testAddBalance(pool, remotesAddr, balance)
 
-			batchesRemotes[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		for j := 0; j < singleCase.size; j++ {
+			batchesRemotes[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remotesKey)
 		}
 
 		batchesRemoteSync[i] = make(types.Transactions, singleCase.size)
 
-		for j := 0; j < singleCase.size; j++ {
-			remoteKey, _ := crypto.GenerateKey()
-			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-			testAddBalance(pool, remoteAddr, balance)
+		remoteSyncKey, _ := crypto.GenerateKey()
+		remoteSyncAddr := crypto.PubkeyToAddress(remoteSyncKey.PublicKey)
+		testAddBalance(pool, remoteSyncAddr, balance)
 
-			batchesRemoteSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		for j := 0; j < singleCase.size; j++ {
+			batchesRemoteSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteSyncKey)
 		}
 
 		batchesRemotesSync[i] = make(types.Transactions, singleCase.size)
 
-		for j := 0; j < singleCase.size; j++ {
-			remoteKey, _ := crypto.GenerateKey()
-			remoteAddr := crypto.PubkeyToAddress(remoteKey.PublicKey)
-			testAddBalance(pool, remoteAddr, balance)
+		remotesSyncKey, _ := crypto.GenerateKey()
+		remotesSyncAddr := crypto.PubkeyToAddress(remotesSyncKey.PublicKey)
+		testAddBalance(pool, remotesSyncAddr, balance)
 
-			batchesRemotesSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+		for j := 0; j < singleCase.size; j++ {
+			batchesRemotesSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remotesSyncKey)
 		}
 	}
 
@@ -3831,14 +3854,18 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 		for _, batch := range batchesLocal {
 			if rand.Int()%2 == 0 {
 				runWithTimeout(t, func(_ chan struct{}) {
-					res := pool.AddLocals(batch)
-					fmt.Fprint(io.Discard, res)
+					errs := pool.AddLocals(batch)
+					if len(errs) != 0 {
+						t.Log("AddLocals error", errs)
+					}
 				}, done, "AddLocals", timeoutDuration)
 			} else {
 				for _, tx := range batch {
 					runWithTimeout(t, func(_ chan struct{}) {
-						res := pool.AddLocal(tx)
-						fmt.Fprint(io.Discard, res)
+						err := pool.AddLocal(tx)
+						if err != nil {
+							t.Log("AddLocal error", err)
+						}
 					}, done, "AddLocal", timeoutDuration)
 
 					time.Sleep(tickerDuration)
@@ -3853,8 +3880,10 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesRemotes {
 			runWithTimeout(t, func(_ chan struct{}) {
-				res := pool.AddRemotes(batch)
-				fmt.Fprint(io.Discard, res)
+				errs := pool.AddRemotes(batch)
+				if len(errs) != 0 {
+					t.Log("AddRemotes error", errs)
+				}
 			}, done, "AddRemotes", timeoutDuration)
 
 			time.Sleep(tickerDuration)
@@ -3866,8 +3895,10 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 		for _, batch := range batchesRemote {
 			for _, tx := range batch {
 				runWithTimeout(t, func(_ chan struct{}) {
-					res := pool.AddRemote(tx)
-					fmt.Fprint(io.Discard, res)
+					err := pool.AddRemote(tx)
+					if err != nil {
+						t.Log("AddRemote error", err)
+					}
 				}, done, "AddRemote", timeoutDuration)
 
 				time.Sleep(tickerDuration)
@@ -3882,8 +3913,10 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesRemotesSync {
 			runWithTimeout(t, func(_ chan struct{}) {
-				res := pool.AddRemotesSync(batch)
-				fmt.Fprint(io.Discard, res)
+				errs := pool.AddRemotesSync(batch)
+				if len(errs) != 0 {
+					t.Log("AddRemotesSync error", errs)
+				}
 			}, done, "AddRemotesSync", timeoutDuration)
 
 			time.Sleep(tickerDuration)
@@ -3895,8 +3928,10 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 		for _, batch := range batchesRemoteSync {
 			for _, tx := range batch {
 				runWithTimeout(t, func(_ chan struct{}) {
-					res := pool.AddRemoteSync(tx)
-					fmt.Fprint(io.Discard, res)
+					err := pool.AddRemoteSync(tx)
+					if err != nil {
+						t.Log("AddRemoteSync error", err)
+					}
 				}, done, "AddRemoteSync", timeoutDuration)
 
 				time.Sleep(tickerDuration)
@@ -4028,9 +4063,7 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 	defer blockTicker.Stop()
 
 	for range blockTicker.C {
-		totalTxs += mining(pool, signer, baseFee)
-
-		t.Log("block", totalBlocks, "transactions", totalTxs)
+		totalTxs += mining(t, pool, signer, baseFee, blockGasLimit, totalBlocks)
 
 		totalBlocks++
 
@@ -4042,7 +4075,7 @@ func apiWithMining(t *testing.T, balanceStr string, batchesSize int, singleCase
 }
 
 //nolint:unparam
-func runWithTicker(t *testing.T, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration) {
+func runWithTicker(t testing.TB, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration) {
 	t.Helper()
 
 	localTicker := time.NewTimer(tickerDuration)
@@ -4059,7 +4092,7 @@ func runWithTicker(t *testing.T, fn func(c chan struct{}), done chan struct{}, n
 	}
 }
 
-func runWithTimeout(t *testing.T, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration) {
+func runWithTimeout(t testing.TB, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration) {
 	t.Helper()
 
 	timeout := time.NewTimer(timeoutDuration)

From 764aeb4f27b14dd5fe6d9bbbe3f1864ef9b2b8f2 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 16:40:32 +0400
Subject: [PATCH 79/96] panic fix

---
 core/tx_list.go | 40 ++++++++++++++++++++++++++++++++++++++--
 core/tx_pool.go |  1 +
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 83d9a8faf6..e2850d139c 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -326,6 +326,43 @@ func (m *txSortedMap) flatten() types.Transactions {
 	return m.cache
 }
 
+func (m *txSortedMap) lastElement() *types.Transaction {
+	// If the sorting was not cached yet, create and cache it
+	m.cacheMu.Lock()
+	defer m.cacheMu.Unlock()
+
+	if m.isEmpty {
+		m.isEmpty = false // to simulate sync.Once
+
+		m.cacheMu.Unlock()
+
+		m.m.RLock()
+		cache := make(types.Transactions, 0, len(m.items))
+
+		for _, tx := range m.items {
+			cache = append(cache, tx)
+		}
+
+		m.m.RUnlock()
+
+		// exclude sorting from locks
+		sort.Sort(types.TxByNonce(cache))
+
+		m.cacheMu.Lock()
+		m.cache = cache
+		// m.cacheMu.Unlock() - deferred
+
+		reinitCacheGauge.Inc(1)
+		missCacheCounter.Inc(1)
+	} else {
+		// m.cacheMu.Unlock() - deferred
+
+		hitCacheCounter.Inc(1)
+	}
+
+	return m.cache[len(m.cache)-1]
+}
+
 // Flatten creates a nonce-sorted slice of transactions based on the loosely
 // sorted internal representation. The result of the sorting is cached in case
 // it's requested again before any modifications are made to the contents.
@@ -337,8 +374,7 @@ func (m *txSortedMap) Flatten() types.Transactions {
 // LastElement returns the last element of a flattened list, thus, the
 // transaction with the highest nonce
 func (m *txSortedMap) LastElement() *types.Transaction {
-	cache := m.flatten()
-	return cache[len(cache)-1]
+	return m.lastElement()
 }
 
 // txList is a "list" of transactions belonging to an account, sorted by account
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 47ff14ae0f..22574d8699 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -2131,6 +2131,7 @@ func (pool *TxPool) demoteUnexecutables() {
 			// This might happen in a reorg, so log it to the metering
 			blockReorgInvalidatedTx.Mark(int64(gappedLen))
 		}
+
 		// Delete the entire pending entry if it became empty.
 		if list.Empty() {
 			pool.pendingMu.RUnlock()

From 67e49d60528343e3988055b4af65158371cc5c74 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 22:21:55 +0400
Subject: [PATCH 80/96] linters

---
 core/tx_list.go      | 20 +++++------
 core/tx_pool_test.go | 84 +++++++++++++++++++++++---------------------
 2 files changed, 54 insertions(+), 50 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index e2850d139c..f5281282e5 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -294,13 +294,16 @@ func (m *txSortedMap) flatten() types.Transactions {
 	m.cacheMu.Lock()
 	defer m.cacheMu.Unlock()
 
+	cache := m.cache
+
 	if m.isEmpty {
 		m.isEmpty = false // to simulate sync.Once
 
 		m.cacheMu.Unlock()
 
+		cache = make(types.Transactions, 0, len(m.items))
+
 		m.m.RLock()
-		cache := make(types.Transactions, 0, len(m.items))
 
 		for _, tx := range m.items {
 			cache = append(cache, tx)
@@ -313,17 +316,14 @@ func (m *txSortedMap) flatten() types.Transactions {
 
 		m.cacheMu.Lock()
 		m.cache = cache
-		// m.cacheMu.Unlock() - deferred
 
 		reinitCacheGauge.Inc(1)
 		missCacheCounter.Inc(1)
 	} else {
-		// m.cacheMu.Unlock() - deferred
-
 		hitCacheCounter.Inc(1)
 	}
 
-	return m.cache
+	return cache
 }
 
 func (m *txSortedMap) lastElement() *types.Transaction {
@@ -331,13 +331,16 @@ func (m *txSortedMap) lastElement() *types.Transaction {
 	m.cacheMu.Lock()
 	defer m.cacheMu.Unlock()
 
+	cache := m.cache
+
 	if m.isEmpty {
 		m.isEmpty = false // to simulate sync.Once
 
 		m.cacheMu.Unlock()
 
+		cache = make(types.Transactions, 0, len(m.items))
+
 		m.m.RLock()
-		cache := make(types.Transactions, 0, len(m.items))
 
 		for _, tx := range m.items {
 			cache = append(cache, tx)
@@ -350,17 +353,14 @@ func (m *txSortedMap) lastElement() *types.Transaction {
 
 		m.cacheMu.Lock()
 		m.cache = cache
-		// m.cacheMu.Unlock() - deferred
 
 		reinitCacheGauge.Inc(1)
 		missCacheCounter.Inc(1)
 	} else {
-		// m.cacheMu.Unlock() - deferred
-
 		hitCacheCounter.Inc(1)
 	}
 
-	return m.cache[len(m.cache)-1]
+	return cache[len(cache)-1]
 }
 
 // Flatten creates a nonce-sorted slice of transactions based on the loosely
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index c2ad8a340d..02ff0f87c2 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -336,9 +336,12 @@ func TestInvalidTransactions(t *testing.T) {
 	}
 
 	tx = transaction(1, 100000, key)
+
 	pool.gasPriceMu.Lock()
+
 	pool.gasPrice = big.NewInt(1000)
 	pool.gasPriceUint = uint256.NewInt(1000)
+
 	pool.gasPriceMu.Unlock()
 
 	if err := pool.AddRemote(tx); !errors.Is(err, ErrUnderpriced) {
@@ -3667,7 +3670,8 @@ func MakeWithPromoteTxCh(ch chan struct{}) func(*TxPool) {
 	}
 }
 
-func mining(t testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) int {
+//nolint:thelper
+func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) int {
 	var (
 		localTxsCount  int
 		remoteTxsCount int
@@ -3714,7 +3718,7 @@ func mining(t testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.In
 		total += txRemoteCount
 	}
 
-	t.Logf("mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d",
+	tb.Logf("mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d",
 		totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen)
 
 	return total
@@ -3767,7 +3771,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 }
 
 //nolint:gocognit,thelper
-func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase struct {
+func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase struct {
 	name string
 	size int
 }, timeoutDuration time.Duration, threads int, tickerDuration time.Duration, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
@@ -3785,7 +3789,7 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 
 	balance, ok := big.NewInt(0).SetString(balanceStr, 0)
 	if !ok {
-		t.Fatal("incorrect initial balance", balanceStr)
+		tb.Fatal("incorrect initial balance", balanceStr)
 	}
 
 	testAddBalance(pool, account, balance)
@@ -3847,24 +3851,24 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 		}
 	}
 
-	t.Log("starting goroutines")
+	tb.Log("starting goroutines")
 
 	// locals
 	go func() {
 		for _, batch := range batchesLocal {
 			if rand.Int()%2 == 0 {
-				runWithTimeout(t, func(_ chan struct{}) {
+				runWithTimeout(tb, func(_ chan struct{}) {
 					errs := pool.AddLocals(batch)
 					if len(errs) != 0 {
-						t.Log("AddLocals error", errs)
+						tb.Log("AddLocals error", errs)
 					}
 				}, done, "AddLocals", timeoutDuration)
 			} else {
 				for _, tx := range batch {
-					runWithTimeout(t, func(_ chan struct{}) {
+					runWithTimeout(tb, func(_ chan struct{}) {
 						err := pool.AddLocal(tx)
 						if err != nil {
-							t.Log("AddLocal error", err)
+							tb.Log("AddLocal error", err)
 						}
 					}, done, "AddLocal", timeoutDuration)
 
@@ -3879,10 +3883,10 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	// remotes
 	go func() {
 		for _, batch := range batchesRemotes {
-			runWithTimeout(t, func(_ chan struct{}) {
+			runWithTimeout(tb, func(_ chan struct{}) {
 				errs := pool.AddRemotes(batch)
 				if len(errs) != 0 {
-					t.Log("AddRemotes error", errs)
+					tb.Log("AddRemotes error", errs)
 				}
 			}, done, "AddRemotes", timeoutDuration)
 
@@ -3894,10 +3898,10 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesRemote {
 			for _, tx := range batch {
-				runWithTimeout(t, func(_ chan struct{}) {
+				runWithTimeout(tb, func(_ chan struct{}) {
 					err := pool.AddRemote(tx)
 					if err != nil {
-						t.Log("AddRemote error", err)
+						tb.Log("AddRemote error", err)
 					}
 				}, done, "AddRemote", timeoutDuration)
 
@@ -3912,10 +3916,10 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	// remotes
 	go func() {
 		for _, batch := range batchesRemotesSync {
-			runWithTimeout(t, func(_ chan struct{}) {
+			runWithTimeout(tb, func(_ chan struct{}) {
 				errs := pool.AddRemotesSync(batch)
 				if len(errs) != 0 {
-					t.Log("AddRemotesSync error", errs)
+					tb.Log("AddRemotesSync error", errs)
 				}
 			}, done, "AddRemotesSync", timeoutDuration)
 
@@ -3927,10 +3931,10 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	go func() {
 		for _, batch := range batchesRemoteSync {
 			for _, tx := range batch {
-				runWithTimeout(t, func(_ chan struct{}) {
+				runWithTimeout(tb, func(_ chan struct{}) {
 					err := pool.AddRemoteSync(tx)
 					if err != nil {
-						t.Log("AddRemoteSync error", err)
+						tb.Log("AddRemoteSync error", err)
 					}
 				}, done, "AddRemoteSync", timeoutDuration)
 
@@ -3944,97 +3948,97 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	// tx pool API
 	for i := 0; i < threads; i++ {
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), false)
 				fmt.Fprint(io.Discard, p)
 			}, done, "Pending-no-tips", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), true)
 				fmt.Fprint(io.Discard, p)
 			}, done, "Pending-with-tips", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				l := pool.Locals()
 				fmt.Fprint(io.Discard, l)
 			}, done, "Locals", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.Content()
 				fmt.Fprint(io.Discard, p, q)
 			}, done, "Content", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.GasPriceUint256()
 				fmt.Fprint(io.Discard, res)
 			}, done, "GasPriceUint256", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.GasPrice()
 				fmt.Fprint(io.Discard, res)
 			}, done, "GasPrice", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				pool.SetGasPrice(pool.GasPrice())
 			}, done, "SetGasPrice", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.ContentFrom(account)
 				fmt.Fprint(io.Discard, p, q)
 			}, done, "ContentFrom", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.Has(batchesRemotes[0][0].Hash())
 				fmt.Fprint(io.Discard, res)
 			}, done, "Has", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				tx := pool.Get(batchesRemotes[0][0].Hash())
 				fmt.Fprint(io.Discard, tx.Hash())
 			}, done, "Get", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.Nonce(account)
 				fmt.Fprint(io.Discard, res)
 			}, done, "Nonce", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.Stats()
 				fmt.Fprint(io.Discard, p, q)
 			}, done, "Stats", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(_ chan struct{}) {
+			runWithTicker(tb, func(_ chan struct{}) {
 				st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
 				fmt.Fprint(io.Discard, st)
 			}, done, "Status", tickerDuration, timeoutDuration)
 		}()
 
 		go func() {
-			runWithTicker(t, func(c chan struct{}) {
+			runWithTicker(tb, func(c chan struct{}) {
 				ch := make(chan NewTxsEvent, 10)
 				sub := pool.SubscribeNewTxsEvent(ch)
 
@@ -4050,9 +4054,9 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	}
 
 	// wait for the start
-	t.Log("before the first propagated transaction")
+	tb.Log("before the first propagated transaction")
 	<-pendingAddedCh
-	t.Log("after the first propagated transaction")
+	tb.Log("after the first propagated transaction")
 
 	var (
 		totalTxs    int
@@ -4063,7 +4067,7 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 	defer blockTicker.Stop()
 
 	for range blockTicker.C {
-		totalTxs += mining(t, pool, signer, baseFee, blockGasLimit, totalBlocks)
+		totalTxs += mining(tb, pool, signer, baseFee, blockGasLimit, totalBlocks)
 
 		totalBlocks++
 
@@ -4075,8 +4079,8 @@ func apiWithMining(t testing.TB, balanceStr string, batchesSize int, singleCase
 }
 
 //nolint:unparam
-func runWithTicker(t testing.TB, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration) {
-	t.Helper()
+func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration) {
+	tb.Helper()
 
 	localTicker := time.NewTimer(tickerDuration)
 	defer localTicker.Stop()
@@ -4088,12 +4092,12 @@ func runWithTicker(t testing.TB, fn func(c chan struct{}), done chan struct{}, n
 		default:
 		}
 
-		runWithTimeout(t, fn, done, name, timeoutDuration)
+		runWithTimeout(tb, fn, done, name, timeoutDuration)
 	}
 }
 
-func runWithTimeout(t testing.TB, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration) {
-	t.Helper()
+func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration) {
+	tb.Helper()
 
 	timeout := time.NewTimer(timeoutDuration)
 	defer timeout.Stop()
@@ -4107,7 +4111,7 @@ func runWithTimeout(t testing.TB, fn func(chan struct{}), outerDone chan struct{
 
 	select {
 	case <-timeout.C:
-		t.Fatalf("%s timeouted", name)
+		tb.Fatalf("%s timeouted", name)
 	case <-outerDone:
 	case <-doneCh:
 	}

From 028961b97de3a8ebab53a8f6334c2de8e6e137cf Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 22:51:31 +0400
Subject: [PATCH 81/96] fix gas fee data race

---
 core/tx_pool.go      | 8 +++++++-
 core/tx_pool_test.go | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 22574d8699..39d183f7d6 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -762,12 +762,18 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if err != nil {
 		return ErrInvalidSender
 	}
-
+	
 	// Drop non-local transactions under our own minimal accepted gas price or tip
+	pool.gasPriceMu.RLock()
+
 	if !local && tx.GasTipCapUIntLt(pool.gasPriceUint) {
+		pool.gasPriceMu.RUnlock()
+
 		return ErrUnderpriced
 	}
 
+	pool.gasPriceMu.RUnlock()
+
 	// Ensure the transaction adheres to nonce ordering
 	if pool.currentState.GetNonce(from) > tx.Nonce() {
 		return ErrNonceTooLow
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 02ff0f87c2..ff28a21b92 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3736,7 +3736,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 		name string
 		size int
 	}{
-		{size: 5},
+		{size: 1},
 		{size: 5},
 		{size: 10},
 		{size: 20},

From f8246e9274606a64a56faa43b18950ee150af118 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 22:52:55 +0400
Subject: [PATCH 82/96] linters

---
 core/tx_pool.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/tx_pool.go b/core/tx_pool.go
index 39d183f7d6..ac2f9e11ee 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -762,7 +762,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if err != nil {
 		return ErrInvalidSender
 	}
-	
+
 	// Drop non-local transactions under our own minimal accepted gas price or tip
 	pool.gasPriceMu.RLock()
 

From 8de32f470c226fe4186211090e49338955205d80 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 3 Nov 2022 23:16:55 +0400
Subject: [PATCH 83/96] more transactions

---
 core/tx_pool_test.go | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index ff28a21b92..52902cfd86 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3855,6 +3855,9 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// locals
 	go func() {
+		tb.Log("starting AddLocal(s)")
+		defer tb.Log("stop AddLocal(s)")
+
 		for _, batch := range batchesLocal {
 			if rand.Int()%2 == 0 {
 				runWithTimeout(tb, func(_ chan struct{}) {
@@ -3882,6 +3885,9 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// remotes
 	go func() {
+		tb.Log("starting AddRemotes")
+		defer tb.Log("stop AddRemotes")
+
 		for _, batch := range batchesRemotes {
 			runWithTimeout(tb, func(_ chan struct{}) {
 				errs := pool.AddRemotes(batch)
@@ -3896,6 +3902,9 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// remote
 	go func() {
+		tb.Log("starting AddRemote")
+		defer tb.Log("stop AddRemote")
+
 		for _, batch := range batchesRemote {
 			for _, tx := range batch {
 				runWithTimeout(tb, func(_ chan struct{}) {
@@ -3915,6 +3924,9 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	// sync
 	// remotes
 	go func() {
+		tb.Log("starting AddRemotesSync")
+		defer tb.Log("stop AddRemotesSync")
+
 		for _, batch := range batchesRemotesSync {
 			runWithTimeout(tb, func(_ chan struct{}) {
 				errs := pool.AddRemotesSync(batch)
@@ -3929,6 +3941,9 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// remote
 	go func() {
+		tb.Log("starting AddRemoteSync")
+		defer tb.Log("stop AddRemoteSync")
+
 		for _, batch := range batchesRemoteSync {
 			for _, tx := range batch {
 				runWithTimeout(tb, func(_ chan struct{}) {
@@ -4111,7 +4126,7 @@ func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct
 
 	select {
 	case <-timeout.C:
-		tb.Fatalf("%s timeouted", name)
+		tb.Errorf("%s timeouted", name)
 	case <-outerDone:
 	case <-doneCh:
 	}

From 4c32b4e0b72baf1a6cd5fbb2935102022dd2e470 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Wed, 9 Nov 2022 10:55:59 +0400
Subject: [PATCH 84/96] debug

---
 Makefile              |      2 +-
 common/debug/debug.go |     24 +
 common/time.go        |      9 +
 core/tx_pool_test.go  |    296 +-
 sync.txt              | 201694 +++++++++++++++++++++++++++++++++++++++
 test1.txt             |   5602 ++
 6 files changed, 207537 insertions(+), 90 deletions(-)
 create mode 100644 common/time.go
 create mode 100644 sync.txt
 create mode 100644 test1.txt

diff --git a/Makefile b/Makefile
index 8550589b77..9552ca2812 100644
--- a/Makefile
+++ b/Makefile
@@ -62,7 +62,7 @@ test:
 	$(GOTEST) --timeout 5m -shuffle=on -cover -short -coverprofile=cover.out $(TESTALL)
 
 test-txpool-race:
-	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 180m -race -v ./core/
+	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 10m -race -v ./core/
 
 test-race:
 	$(GOTEST) --timeout 15m -race -shuffle=on $(TESTALL)
diff --git a/common/debug/debug.go b/common/debug/debug.go
index 6a677e495d..6c1681859e 100644
--- a/common/debug/debug.go
+++ b/common/debug/debug.go
@@ -1,6 +1,7 @@
 package debug
 
 import (
+	"fmt"
 	"runtime"
 )
 
@@ -26,3 +27,26 @@ func Callers(show int) []string {
 
 	return callers
 }
+
+func CodeLine() (string, string, int) {
+	pc, filename, line, _ := runtime.Caller(1)
+	return runtime.FuncForPC(pc).Name(), filename, line
+}
+
+func CodeLineStr() string {
+	pc, filename, line, _ := runtime.Caller(1)
+	return fmt.Sprintf("%s:%d - %s", filename, line, runtime.FuncForPC(pc).Name())
+}
+
+func Stack(all bool) []byte {
+	buf := make([]byte, 4096)
+	for {
+		n := runtime.Stack(buf, all)
+		if n < len(buf) {
+			return buf[:n]
+		}
+		buf = make([]byte, 2*len(buf))
+	}
+
+	return buf
+}
diff --git a/common/time.go b/common/time.go
new file mode 100644
index 0000000000..6c7662e04c
--- /dev/null
+++ b/common/time.go
@@ -0,0 +1,9 @@
+package common
+
+import "time"
+
+const TimeMilliseconds = "15:04:05.000"
+
+func NowMilliseconds() string {
+	return time.Now().Format(TimeMilliseconds)
+}
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 52902cfd86..46058a8887 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -40,6 +40,7 @@ import (
 	"pgregory.net/rapid"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/debug"
 	"github.com/ethereum/go-ethereum/common/leak"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -3718,8 +3719,8 @@ func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.I
 		total += txRemoteCount
 	}
 
-	tb.Logf("mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d",
-		totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen)
+	tb.Logf("[%s] mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d",
+		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen)
 
 	return total
 }
@@ -3759,8 +3760,8 @@ func TestPoolMiningDataRaces(t *testing.T) {
 				blockPeriod     = time.Second
 				threads         = 10
 				batchesSize     = 10_000
-				timeoutDuration = 3 * time.Second
-				tickerDuration  = 5 * time.Millisecond
+				timeoutDuration = 10 * blockPeriod
+				tickerDuration  = 50 * time.Millisecond
 
 				balanceStr = "1_000_000_000"
 			)
@@ -3776,7 +3777,18 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	size int
 }, timeoutDuration time.Duration, threads int, tickerDuration time.Duration, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
 	done := make(chan struct{})
-	defer close(done)
+
+	var wg sync.WaitGroup
+
+	defer func() {
+		close(done)
+
+		tb.Logf("[%s] finishing apiWithMining", common.NowMilliseconds())
+
+		wg.Wait()
+
+		tb.Logf("[%s] apiWithMining finished", common.NowMilliseconds())
+	}()
 
 	// Generate a batch of transactions to enqueue into the pool
 	pendingAddedCh := make(chan struct{}, 1024)
@@ -3851,29 +3863,36 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}
 	}
 
-	tb.Log("starting goroutines")
+	tb.Logf("[%s] starting goroutines", common.NowMilliseconds())
 
 	// locals
+	wg.Add(1)
 	go func() {
-		tb.Log("starting AddLocal(s)")
-		defer tb.Log("stop AddLocal(s)")
+		defer wg.Done()
+
+		tb.Logf("[%s] starting AddLocal(s)", common.NowMilliseconds())
+		defer tb.Logf("[%s] stop AddLocal(s)", common.NowMilliseconds())
 
 		for _, batch := range batchesLocal {
+			batch := batch
+
 			if rand.Int()%2 == 0 {
 				runWithTimeout(tb, func(_ chan struct{}) {
 					errs := pool.AddLocals(batch)
 					if len(errs) != 0 {
-						tb.Log("AddLocals error", errs)
+						tb.Logf("[%s] AddLocals error, %v", common.NowMilliseconds(), errs)
 					}
-				}, done, "AddLocals", timeoutDuration)
+				}, done, "AddLocals", timeoutDuration, 0, 0)
 			} else {
 				for _, tx := range batch {
+					tx := tx
+
 					runWithTimeout(tb, func(_ chan struct{}) {
 						err := pool.AddLocal(tx)
 						if err != nil {
-							tb.Log("AddLocal error", err)
+							tb.Logf("[%s] AddLocal error %s", common.NowMilliseconds(), err)
 						}
-					}, done, "AddLocal", timeoutDuration)
+					}, done, "AddLocal", timeoutDuration, 0, 0)
 
 					time.Sleep(tickerDuration)
 				}
@@ -3884,175 +3903,175 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	}()
 
 	// remotes
+	wg.Add(1)
 	go func() {
-		tb.Log("starting AddRemotes")
-		defer tb.Log("stop AddRemotes")
-
-		for _, batch := range batchesRemotes {
-			runWithTimeout(tb, func(_ chan struct{}) {
-				errs := pool.AddRemotes(batch)
-				if len(errs) != 0 {
-					tb.Log("AddRemotes error", errs)
-				}
-			}, done, "AddRemotes", timeoutDuration)
+		defer wg.Done()
 
-			time.Sleep(tickerDuration)
-		}
+		addTransactionsBatches(tb, batchesRemotes, getFnForBatches(pool.AddRemotes), done, timeoutDuration, tickerDuration, "AddRemotes", 0)
 	}()
 
 	// remote
+	wg.Add(1)
 	go func() {
-		tb.Log("starting AddRemote")
-		defer tb.Log("stop AddRemote")
-
-		for _, batch := range batchesRemote {
-			for _, tx := range batch {
-				runWithTimeout(tb, func(_ chan struct{}) {
-					err := pool.AddRemote(tx)
-					if err != nil {
-						tb.Log("AddRemote error", err)
-					}
-				}, done, "AddRemote", timeoutDuration)
+		defer wg.Done()
 
-				time.Sleep(tickerDuration)
-			}
-
-			time.Sleep(tickerDuration)
-		}
+		addTransactions(tb, batchesRemote, pool.AddRemote, done, timeoutDuration, tickerDuration, "AddRemote", 0)
 	}()
 
 	// sync
 	// remotes
+	wg.Add(1)
 	go func() {
-		tb.Log("starting AddRemotesSync")
-		defer tb.Log("stop AddRemotesSync")
+		defer wg.Done()
 
-		for _, batch := range batchesRemotesSync {
-			runWithTimeout(tb, func(_ chan struct{}) {
-				errs := pool.AddRemotesSync(batch)
-				if len(errs) != 0 {
-					tb.Log("AddRemotesSync error", errs)
-				}
-			}, done, "AddRemotesSync", timeoutDuration)
-
-			time.Sleep(tickerDuration)
-		}
+		go addTransactionsBatches(tb, batchesRemotesSync, getFnForBatches(pool.AddRemotesSync), done, timeoutDuration, tickerDuration, "AddRemotesSync", 0)
 	}()
 
 	// remote
+	wg.Add(1)
 	go func() {
-		tb.Log("starting AddRemoteSync")
-		defer tb.Log("stop AddRemoteSync")
-
-		for _, batch := range batchesRemoteSync {
-			for _, tx := range batch {
-				runWithTimeout(tb, func(_ chan struct{}) {
-					err := pool.AddRemoteSync(tx)
-					if err != nil {
-						tb.Log("AddRemoteSync error", err)
-					}
-				}, done, "AddRemoteSync", timeoutDuration)
-
-				time.Sleep(tickerDuration)
-			}
+		defer wg.Done()
 
-			time.Sleep(tickerDuration)
-		}
+		addTransactions(tb, batchesRemoteSync, pool.AddRemoteSync, done, timeoutDuration, tickerDuration, "AddRemoteSync", 0)
 	}()
 
 	// tx pool API
 	for i := 0; i < threads; i++ {
+		i := i
+
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), false)
 				fmt.Fprint(io.Discard, p)
-			}, done, "Pending-no-tips", tickerDuration, timeoutDuration)
+			}, done, "Pending-no-tips", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), true)
 				fmt.Fprint(io.Discard, p)
-			}, done, "Pending-with-tips", tickerDuration, timeoutDuration)
+			}, done, "Pending-with-tips", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				l := pool.Locals()
 				fmt.Fprint(io.Discard, l)
-			}, done, "Locals", tickerDuration, timeoutDuration)
+			}, done, "Locals", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.Content()
 				fmt.Fprint(io.Discard, p, q)
-			}, done, "Content", tickerDuration, timeoutDuration)
+			}, done, "Content", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.GasPriceUint256()
 				fmt.Fprint(io.Discard, res)
-			}, done, "GasPriceUint256", tickerDuration, timeoutDuration)
+			}, done, "GasPriceUint256", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.GasPrice()
 				fmt.Fprint(io.Discard, res)
-			}, done, "GasPrice", tickerDuration, timeoutDuration)
+			}, done, "GasPrice", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				pool.SetGasPrice(pool.GasPrice())
-			}, done, "SetGasPrice", tickerDuration, timeoutDuration)
+			}, done, "SetGasPrice", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.ContentFrom(account)
 				fmt.Fprint(io.Discard, p, q)
-			}, done, "ContentFrom", tickerDuration, timeoutDuration)
+			}, done, "ContentFrom", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.Has(batchesRemotes[0][0].Hash())
 				fmt.Fprint(io.Discard, res)
-			}, done, "Has", tickerDuration, timeoutDuration)
+			}, done, "Has", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				tx := pool.Get(batchesRemotes[0][0].Hash())
 				fmt.Fprint(io.Discard, tx.Hash())
-			}, done, "Get", tickerDuration, timeoutDuration)
+			}, done, "Get", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.Nonce(account)
 				fmt.Fprint(io.Discard, res)
-			}, done, "Nonce", tickerDuration, timeoutDuration)
+			}, done, "Nonce", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.Stats()
 				fmt.Fprint(io.Discard, p, q)
-			}, done, "Stats", tickerDuration, timeoutDuration)
+			}, done, "Stats", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(_ chan struct{}) {
 				st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
 				fmt.Fprint(io.Discard, st)
-			}, done, "Status", tickerDuration, timeoutDuration)
+			}, done, "Status", tickerDuration, timeoutDuration, i)
 		}()
 
+		wg.Add(1)
 		go func() {
+			defer wg.Done()
+
 			runWithTicker(tb, func(c chan struct{}) {
 				ch := make(chan NewTxsEvent, 10)
 				sub := pool.SubscribeNewTxsEvent(ch)
@@ -4064,14 +4083,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 				}
 
 				sub.Unsubscribe()
-			}, done, "SubscribeNewTxsEvent", tickerDuration, timeoutDuration)
+			}, done, "SubscribeNewTxsEvent", tickerDuration, timeoutDuration, i)
 		}()
 	}
 
 	// wait for the start
-	tb.Log("before the first propagated transaction")
+	tb.Logf("[%s] before the first propagated transaction", common.NowMilliseconds())
 	<-pendingAddedCh
-	tb.Log("after the first propagated transaction")
+	tb.Logf("[%s] after the first propagated transaction", common.NowMilliseconds())
 
 	var (
 		totalTxs    int
@@ -4093,13 +4112,74 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	}
 }
 
+func addTransactionsBatches(tb testing.TB, batches []types.Transactions, fn func(types.Transactions) error, done chan struct{}, timeoutDuration time.Duration, tickerDuration time.Duration, name string, thread int) {
+	tb.Logf("[%s] starting %s", common.NowMilliseconds(), name)
+	defer func() {
+		tb.Logf("[%s] stop %s", common.NowMilliseconds(), name)
+	}()
+
+	for _, batch := range batches {
+		batch := batch
+
+		runWithTimeout(tb, func(_ chan struct{}) {
+			err := fn(batch)
+			if err != nil {
+				tb.Logf("[%s] %s error: %s", common.NowMilliseconds(), name, err)
+			}
+		}, done, name, timeoutDuration, 0, thread)
+
+		time.Sleep(tickerDuration)
+	}
+}
+
+func addTransactions(tb testing.TB, batches []types.Transactions, fn func(*types.Transaction) error, done chan struct{}, timeoutDuration time.Duration, tickerDuration time.Duration, name string, thread int) {
+	tb.Logf("[%s] starting %s", common.NowMilliseconds(), name)
+	defer func() {
+		tb.Logf("[%s] stop %s", common.NowMilliseconds(), name)
+	}()
+
+	for _, batch := range batches {
+		for _, tx := range batch {
+			tx := tx
+
+			runWithTimeout(tb, func(_ chan struct{}) {
+				err := fn(tx)
+				if err != nil {
+					tb.Logf("%s error: %s", name, err)
+				}
+			}, done, name, timeoutDuration, 0, thread)
+
+			time.Sleep(tickerDuration)
+		}
+
+		time.Sleep(tickerDuration)
+	}
+}
+
+func getFnForBatches(fn func([]*types.Transaction) []error) func(types.Transactions) error {
+	return func(batch types.Transactions) error {
+		errs := fn(batch)
+		if len(errs) != 0 {
+			return errs[0]
+		}
+
+		return nil
+	}
+}
+
 //nolint:unparam
-func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration) {
+func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration, thread int) {
 	tb.Helper()
 
+	defer func() {
+		tb.Logf("[%s] finishing outer runWithTicker for %q, thread %d", common.NowMilliseconds(), name, thread)
+	}()
+
 	localTicker := time.NewTimer(tickerDuration)
 	defer localTicker.Stop()
 
+	n := 0
+
 	for range localTicker.C {
 		select {
 		case <-done:
@@ -4107,27 +4187,65 @@ func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{},
 		default:
 		}
 
-		runWithTimeout(tb, fn, done, name, timeoutDuration)
+		runWithTimeout(tb, fn, done, name, timeoutDuration, n, thread)
+
+		n++
 	}
 }
 
-func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration) {
+func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration, n, thread int) {
 	tb.Helper()
 
+	/*
+		defer func() {
+			tb.Logf("[%s] finishing inner runWithTimeout for %q, thread %d, iteration %d",
+				common.NowMilliseconds(), name, thread, n)
+		}()
+
+	*/
+
 	timeout := time.NewTimer(timeoutDuration)
 	defer timeout.Stop()
 
 	doneCh := make(chan struct{})
-	defer close(doneCh)
+
+	isError := new(int32)
+	*isError = 0
 
 	go func() {
+		defer close(doneCh)
+
+		/*
+			tb.Logf("[%s] starting inner runWithTimeout for %q, timeout in %v, thread %d, iteration %d",
+				common.NowMilliseconds(), name, timeoutDuration, thread, n)
+
+		*/
+
 		fn(doneCh)
+
+		/*
+			tb.Logf("[%s] finished inner runWithTimeout for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
+
+		*/
 	}()
 
+	const isDebug = false
+
+	var stack string
+
 	select {
 	case <-timeout.C:
-		tb.Errorf("%s timeouted", name)
+		atomic.StoreInt32(isError, 1)
+
+		if isDebug {
+			stack = string(debug.Stack(true))
+		}
+
+		tb.Errorf("[%s] %s timeouted, thread %d, iteration %d. Stack %s", common.NowMilliseconds(), name, thread, n, stack)
+
 	case <-outerDone:
+		tb.Logf("[%s] exiting inner runWithTimeout by outer exit event for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
 	case <-doneCh:
+		// tb.Logf("[%s] exiting inner runWithTimeout by successful call for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
 	}
 }
diff --git a/sync.txt b/sync.txt
new file mode 100644
index 0000000000..cff94a1071
--- /dev/null
+++ b/sync.txt
@@ -0,0 +1,201694 @@
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc00618a000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00477c000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc00618a000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc00618a000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).Fail(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc00637e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc0064be000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc0064be000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc00755c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc007264000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc006b04000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0074a8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc007264000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc006b04000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0074a8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc006919721, 0x3e})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [runnable]:
+        fmt.(*pp).free(0xc002450000)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc00691a9db, 0x3d})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc00691b7b1, 0x80})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc00691e2b4, 0xbc})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc006920d82, 0xbd})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc006924703, 0x3e})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [runnable]:
+        time.Time.Format({0xc0036eeaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc00692d5ff, 0x9f})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc00692803d, 0x90})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc00019a2b0, {0xc005fb6000, 0x25cfa})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc00011e110, {0x104d96da6, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc007d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc007cd6000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc007d06000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc00692d5ff, 0x9f})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc0022c21e0, {0xc0062ec000, 0x232f2})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc0069348a1, 0x32})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0xc0069361a3, 0x1b})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [runnable]:
+        fmt.(*pp).free(0xc0022c21a0)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteString(0xc004696040, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        strings.(*Builder).WriteByte(0xc004696040, 0xa)
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:96 +0x1a4
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:683 +0x288
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        os.(*File).Write(0xc000120008, {0xc006894000, 0x28588, 0x2a000})
+        	/Users/jekamas/go/go1.19.2/src/os/file.go:171 +0x410
+        fmt.Fprintf({0x1050f5e60, 0xc000120008}, {0x104d95c29, 0x2}, {0xc0040c9a48, 0x1, 0x1})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:205 +0x98
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [runnable]:
+        fmt.glob..func1()
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:132 +0x2c
+        sync.(*Pool).Get(0x1055aa560)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:151 +0x12c
+        fmt.newPrinter()
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:137 +0x2c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:218 +0x38
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        syscall.syscall(0x104d5ad24?, 0x10680ba00?, 0x106544408?, 0x0?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sys_darwin.go:22 +0x54
+        syscall.write(0xc0040c9668?, {0xc006894000, 0x28588, 0x0?})
+        	/Users/jekamas/go/go1.19.2/src/syscall/zsyscall_darwin_arm64.go:1653 +0x64
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*pp).doPrintf(0xc004c5e0d0, {0x104dc934d, 0x43}, {0xc003984000?, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:1018 +0x13c
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 200 [semacquire]:
+        runtime.Stack({0xc0088b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc008ade000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0089fe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [runnable]:
+        fmt.(*pp).doPrintf(0xc00011edd0, {0x104dc39f9, 0x34}, {0xc0040a08c0?, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:1005 +0x157c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:219 +0x54
+--
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [GC assist wait]:
+        testing.(*common).frameSkip(0xc0004704e0, 0x4)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
+        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [GC assist wait]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        runtime.Stack({0xc008ade000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0089fe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 199 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.genSplit({0xc006ab8000, 0x2467f}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:250 +0x8c
+        strings.Split(...)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0xc006ab9200, 0x37})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc00011f560, {0xc00956e000, 0x2b26d})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0xc006abadc9, 0x3d})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 98 [semacquire]:
+        runtime.Stack({0xc009120000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0xc006ac801a, 0x3d})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 80 [semacquire]:
+        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [runnable]:
+        fmt.(*pp).free(0xc00011f6c0)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0xc006acd5cf, 0xbc})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        runtime.Stack({0xc009120000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0xc006ad487d, 0x3b})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        runtime.Stack({0xc009120000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
+        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        os.(*File).Write(0xc000120008, {0xc009c40000, 0x28d59, 0x2a000})
+        	/Users/jekamas/go/go1.19.2/src/os/file.go:171 +0x410
+        fmt.Fprintf({0x1050f5e60, 0xc000120008}, {0x104d95c29, 0x2}, {0xc0040cba48, 0x1, 0x1})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:205 +0x98
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc0022c2930, {0xc009aca000, 0x28d59})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [runnable]:
+        fmt.(*fmt).padString(0xc0040f6520, {0xc009d04000, 0x2c8b7})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:108 +0x3c0
+        fmt.(*fmt).fmtS(0xc0040f6520, {0xc009d04000, 0x2c8b7})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:359 +0x7c
+--
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [runnable]:
+        syscall.syscall(0x104d5ad24?, 0x106818300?, 0x106544408?, 0x0?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sys_darwin.go:22 +0x54
+        syscall.write(0xc0040cb668?, {0xc009c40000, 0x28d59, 0x0?})
+        	/Users/jekamas/go/go1.19.2/src/syscall/zsyscall_darwin_arm64.go:1653 +0x64
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [runnable]:
+        fmt.(*pp).free(0xc00011fad0)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
+--
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc0022c2a00, {0xc00a234000, 0x2c921})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [runnable]:
+        fmt.(*pp).free(0xc0022c29c0)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 188 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 208 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 211 [semacquire]:
+        runtime.Stack({0xc009240000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [runnable]:
+        runtime.Gosched(...)
+        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 139 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 178 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [GC assist wait]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [GC assist wait]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc0025e86c0, {0xc00b5ea000, 0x2ac38})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 142 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 202 [semacquire]:
+        runtime.Stack({0xc0097ce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [GC assist wait]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [GC assist wait]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc0025e86c0, {0xc00b5ea000, 0x2ac38})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 181 [semacquire]:
+        runtime.Stack({0xc007844000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 155 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 220 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 150 [semacquire]:
+        runtime.Stack({0xc009eb2000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 222 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0a0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 196 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 113 [semacquire]:
+        runtime.Stack({0xc009f4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 205 [semacquire]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        time.Time.Format({0xc005b28af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        time.Time.Format({0xc004bf0af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        time.Time.Format({0xc0030a8ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 96 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        time.Time.Format({0xc000be8ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        time.Time.Format({0xc004c45af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        time.Time.Format({0xc005b36af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+--
+        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 143 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        time.Time.Format({0xc0030c6af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*pp).doPrintf(0xc0022c2000, {0x104dc39f9, 0x34}, {0xc00222e000?, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:1018 +0x18c
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        time.Time.Format({0xc0040a9af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc00a8dc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 188 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        time.Time.Format({0xc004c48af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        time.Time.Format({0xc0036eaad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        time.Time.Format({0xc0036e9ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        time.Time.Format({0xc00229aad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [runnable]:
+        fmt.(*pp).fmtInteger(0xc00260c000, 0x7?, 0x1, 0x64)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:401 +0x264
+        fmt.(*pp).printArg(0xc00260c000, {0x104ff9980?, 0x1055809d8}, 0x64)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:703 +0x8ac
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        time.Time.Format({0xc0040a7af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc0025e86c0, {0xc00b5ea000, 0x2ac38})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        time.Time.Format({0xc002424af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        runtime.Stack({0xc00a95c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 192 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 148 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 110 [semacquire]:
+        runtime.Stack({0xc009e44000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 78 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22030, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x126315300b5c4be8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x8d844fea542bd4c0?, {0x104d96da6, 0x5}, 0xffffffffffffffff?, 0x437e2838ecedf676?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 73 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 68 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        time.Time.Format({0xc005b28af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        time.Time.Format({0xc004bf0af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        time.Time.Format({0xc0030a8ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c5d8a8?, 0x3c?, 0xc000c5d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ef6000, 0x2afbb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 85 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 96 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d9888?, 0x3c?, 0xc0037d98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005fb6000, 0x2c764}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 104 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        time.Time.Format({0xc004c45af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e78a8?, 0x3c?, 0xc0010e78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b76e000, 0x29a4c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde020, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe41a0ae05b327e52?, 0xccb003e040557d96?, {0x104d99fcb, 0x8}, 0xea4f35e83d4779ac?, 0xc09a03772fe97cf0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 131 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cf8a8?, 0x3c?, 0xc0037cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0060fc000, 0x2ca93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0c0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x30f0a0b030d0c?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x74f63f51cbac4c35?, 0x7bebb4f219b7fcfd?, {0x104d9c53b, 0xb}, 0xba192169bf4389e5?, 0x50eb46bed0436478?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 132 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c98a8?, 0x3c?, 0xc0037c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005c90000, 0x2ab8d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 139 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038a78a8?, 0x3c?, 0xc0038a78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0045a8000, 0x2b732}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 140 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0006658a8?, 0x3c?, 0xc0006658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005de0000, 0x2b55b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 142 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 143 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000663888?, 0x3c?, 0xc0006638b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006220000, 0x2b0d9}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 150 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x462154a84dbff288?, {0x104d96da6, 0x5}, 0xc2a3fb52904c6a09?, 0x42f9909cf99263d1?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00388b8a8?, 0x3c?, 0xc00388b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0060d0000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 155 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037f7888?, 0x3c?, 0xc0037f78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005c64000, 0x2bac2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 178 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cb8a8?, 0x3c?, 0xc0037cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f50000, 0x2c84f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 181 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc00a8dc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 188 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        time.Time.Format({0xc004c48af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [runnable]:
+        time.Time.Format({0xc0036eaad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002761888?, 0x3c?, 0xc0027618b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006278000, 0x2c937}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 196 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c618a8?, 0x3c?, 0xc000c618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d88000, 0x2aedf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x66f66ad030295201?, 0x4e8269c18f707ffb?, {0x104da355c, 0x14}, 0xe245c7bcc1a4860a?, 0x84b09ee8ae152305?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 197 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0006618a8?, 0x3c?, 0xc0006618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005db4000, 0x2b1c8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 202 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa100, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x60dd51c1a28748f5?, 0x2ae8e60c20f6807e?, {0x104d99fcb, 0x8}, 0x82f35a4d2cfef6a?, 0x9a81dc1c4ef13c4c?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038a9888?, 0x3c?, 0xc0038a98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005be0000, 0x2b38c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 208 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024658a8?, 0x3c?, 0xc0024658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005bb2000, 0x2cf7c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 211 [runnable]:
+        time.Time.Format({0xc000bfaaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002463888?, 0x3c?, 0xc0024638b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00619a000, 0x2ac73}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 220 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037eb888?, 0x3c?, 0xc0037eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00624c000, 0x2b2a5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 222 [semacquire]:
+        time.Time.Format({0xc000bfeaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        time.Time.Format({0xc002424af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 125 [select]:
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20.1(0xc0024189c0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4079 +0xac
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4214 +0x21c
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 190 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 84 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 229 [semacquire]:
+        runtime.Stack({0xc00a07c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006804000, 0x2c119}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be47d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be47d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c5d8a8?, 0x3c?, 0xc000c5d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ef6000, 0x2afbb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 85 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 96 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d9888?, 0x3c?, 0xc0037d98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005fb6000, 0x2c764}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 104 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037e98a8?, 0x3c?, 0xc0037e98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0089b6000, 0x2c206}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 110 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092040, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0022d2f00?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9?, 0xc0039bd260?, {0x104da0b46, 0x11}, 0xc0039bd500?, 0x6?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024698a8?, 0x3c?, 0xc0024698d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0064b6000, 0x2c681}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 113 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0d0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb9512736602a5dfc?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x79c2e1f7d5932de3?, 0x1265a686a452d8c0?, {0x104d9f0db, 0xf}, 0x6e8c12fa5961f9cd?, 0x4120603dc6d69c26?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e78a8?, 0x3c?, 0xc0010e78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b76e000, 0x29a4c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde020, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe41a0ae05b327e52?, 0xccb003e040557d96?, {0x104d99fcb, 0x8}, 0xea4f35e83d4779ac?, 0xc09a03772fe97cf0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 131 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cf8a8?, 0x3c?, 0xc0037cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0060fc000, 0x2ca93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0c0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x30f0a0b030d0c?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x74f63f51cbac4c35?, 0x7bebb4f219b7fcfd?, {0x104d9c53b, 0xb}, 0xba192169bf4389e5?, 0x50eb46bed0436478?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 132 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d5888?, 0x3c?, 0xc0037d58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006674000, 0x2c4b7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xb1094e773a9c3940?, 0xc3c88717e9453e42?, {0x104d9c341, 0xb}, 0x333a4de91c7dac9?, 0x1?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 133 [runnable]:
+        syscall.syscall(0x104d5ad24?, 0x106812000?, 0x106544408?, 0x0?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sys_darwin.go:22 +0x54
+        syscall.write(0xc0030f9648?, {0xc0064e4000, 0x2907b, 0x0?})
+        	/Users/jekamas/go/go1.19.2/src/syscall/zsyscall_darwin_arm64.go:1653 +0x64
+--
+        sync.runtime_SemacquireMutex(0xc0037e7888?, 0x3c?, 0xc0037e78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b44000, 0x2bc90}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b0230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x89cda42b30ed56bc?, 0xe4aa3a086dfc43a6?, {0x104d95edd, 0x3}, 0x0?, 0x50b8a5dae714f931?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 135 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c98a8?, 0x3c?, 0xc0037c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005c90000, 0x2ab8d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 139 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038a78a8?, 0x3c?, 0xc0038a78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0045a8000, 0x2b732}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 140 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0006658a8?, 0x3c?, 0xc0006658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005de0000, 0x2b55b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 142 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 143 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d18a8?, 0x3c?, 0xc0037d18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00654e000, 0x2c59e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 146 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010c1888?, 0x3c?, 0xc0010c18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006a70000, 0x2af07}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 148 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000663888?, 0x3c?, 0xc0006638b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006220000, 0x2b0d9}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 150 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x462154a84dbff288?, {0x104d96da6, 0x5}, 0xc2a3fb52904c6a09?, 0x42f9909cf99263d1?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00388b8a8?, 0x3c?, 0xc00388b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0060d0000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 155 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037f7888?, 0x3c?, 0xc0037f78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005c64000, 0x2bac2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 178 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cb8a8?, 0x3c?, 0xc0037cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f50000, 0x2c84f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 181 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cd888?, 0x3c?, 0xc0037cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006732000, 0x2c3cb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x3f2fbf8d966dae93?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x9f214d9212d7abb8?, {0x104d97bc4, 0x6}, 0x99873abea0229301?, 0x0?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 182 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010c38a8?, 0x3c?, 0xc0010c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066a2000, 0x2d0f7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0f0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc3439c568f92abad?, 0x4ad38caef681d72a?, {0x104da355c, 0x14}, 0x2a284303df5bf8e6?, 0x816567eb32106814?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 183 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        runtime.Stack({0xc00a8dc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 188 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037db888?, 0x3c?, 0xc0037db8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006790000, 0x2c2e3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 192 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002761888?, 0x3c?, 0xc0027618b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006278000, 0x2c937}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 196 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c618a8?, 0x3c?, 0xc000c618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d88000, 0x2aedf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x66f66ad030295201?, 0x4e8269c18f707ffb?, {0x104da355c, 0x14}, 0xe245c7bcc1a4860a?, 0x84b09ee8ae152305?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 197 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0006618a8?, 0x3c?, 0xc0006618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005db4000, 0x2b1c8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 202 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa100, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x60dd51c1a28748f5?, 0x2ae8e60c20f6807e?, {0x104d99fcb, 0x8}, 0x82f35a4d2cfef6a?, 0x9a81dc1c4ef13c4c?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037e5888?, 0x3c?, 0xc0037e58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065e0000, 0x2be68}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 205 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038a9888?, 0x3c?, 0xc0038a98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005be0000, 0x2b38c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 208 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024658a8?, 0x3c?, 0xc0024658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005bb2000, 0x2cf7c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 211 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037f98a8?, 0x3c?, 0xc0037f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006832000, 0x2bf53}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 212 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002463888?, 0x3c?, 0xc0024638b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00619a000, 0x2ac73}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 220 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037eb888?, 0x3c?, 0xc0037eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00624c000, 0x2b2a5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 222 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d78a8?, 0x3c?, 0xc0037d78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006a9c000, 0x2c02e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0a0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 223 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [runnable]:
+        time.Time.Format({0xc002424af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010bf888?, 0x3c?, 0xc0010bf8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00685e000, 0x2afee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b327d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0150, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x6af358bcb1d9d13b?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2e2ac2be0e0754ac?, 0x87e6aff85ef86711?, {0x104d95eec, 0x3}, 0x89a21b1236da5645?, 0x3e6436d15c2479ba?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 234 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2120, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xa8db55a668ba35ab?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf9a0445d45b635f5?, 0xea709bcf68bb8ea7?, {0x104d95edd, 0x3}, 0x29bab3ca1f705044?, 0xf0edf6feb98874d2?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 92 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006804000, 0x2c119}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00388d8a8?, 0x3c?, 0xc00388d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008a94000, 0x2bbb5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 68 [runnable]:
+        strings.genSplit({0xc006b70000, 0x245b4}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:250 +0x8c
+        strings.Split(...)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
+--
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0011138a8?, 0x3c?, 0xc0011138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008a68000, 0x2ae27}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 73 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 74 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc003889888?, 0x3c?, 0xc0038898b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0079ac000, 0x2b9dd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b03c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 76 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037fb888?, 0x3c?, 0xc0037fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008a10000, 0x2b811}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 78 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038ab8a8?, 0x3c?, 0xc0038ab8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00780c000, 0x2b8f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22030, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x126315300b5c4be8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x8d844fea542bd4c0?, {0x104d96da6, 0x5}, 0xffffffffffffffff?, 0x437e2838ecedf676?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 6 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00110f8a8?, 0x3c?, 0xc00110f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008b7a000, 0x2ad3c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be47d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 84 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c5d8a8?, 0x3c?, 0xc000c5d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ef6000, 0x2afbb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 85 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 90 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 96 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 103 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d9888?, 0x3c?, 0xc0037d98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005fb6000, 0x2c764}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 104 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 107 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037e98a8?, 0x3c?, 0xc0037e98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0089b6000, 0x2c206}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 110 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092040, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0022d2f00?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9?, 0xc0039bd260?, {0x104da0b46, 0x11}, 0xc0039bd500?, 0x6?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024698a8?, 0x3c?, 0xc0024698d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0064b6000, 0x2c681}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 113 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0d0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb9512736602a5dfc?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x79c2e1f7d5932de3?, 0x1265a686a452d8c0?, {0x104d9f0db, 0xf}, 0x6e8c12fa5961f9cd?, 0x4120603dc6d69c26?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e78a8?, 0x3c?, 0xc0010e78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b76e000, 0x29a4c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde020, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe41a0ae05b327e52?, 0xccb003e040557d96?, {0x104d99fcb, 0x8}, 0xea4f35e83d4779ac?, 0xc09a03772fe97cf0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 131 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cf8a8?, 0x3c?, 0xc0037cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0060fc000, 0x2ca93}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0c0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x30f0a0b030d0c?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x74f63f51cbac4c35?, 0x7bebb4f219b7fcfd?, {0x104d9c53b, 0xb}, 0xba192169bf4389e5?, 0x50eb46bed0436478?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 132 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d5888?, 0x3c?, 0xc0037d58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006674000, 0x2c4b7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xb1094e773a9c3940?, 0xc3c88717e9453e42?, {0x104d9c341, 0xb}, 0x333a4de91c7dac9?, 0x1?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 133 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030f97b8?, 0x3c?, 0xc0030f97e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c380a0, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 134 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037e7888?, 0x3c?, 0xc0037e78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b44000, 0x2bc90}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b0230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x89cda42b30ed56bc?, 0xe4aa3a086dfc43a6?, {0x104d95edd, 0x3}, 0x0?, 0x50b8a5dae714f931?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 135 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037c98a8?, 0x3c?, 0xc0037c98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005c90000, 0x2ab8d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 139 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038a78a8?, 0x3c?, 0xc0038a78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0045a8000, 0x2b732}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 140 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0006658a8?, 0x3c?, 0xc0006658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005de0000, 0x2b55b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 142 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 143 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 145 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d18a8?, 0x3c?, 0xc0037d18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00654e000, 0x2c59e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 146 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010c1888?, 0x3c?, 0xc0010c18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006a70000, 0x2af07}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 148 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000663888?, 0x3c?, 0xc0006638b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006220000, 0x2b0d9}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 150 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x462154a84dbff288?, {0x104d96da6, 0x5}, 0xc2a3fb52904c6a09?, 0x42f9909cf99263d1?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00388b8a8?, 0x3c?, 0xc00388b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0060d0000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 155 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037f7888?, 0x3c?, 0xc0037f78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005c64000, 0x2bac2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 178 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cb8a8?, 0x3c?, 0xc0037cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f50000, 0x2c84f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 181 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037cd888?, 0x3c?, 0xc0037cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006732000, 0x2c3cb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x3f2fbf8d966dae93?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x9f214d9212d7abb8?, {0x104d97bc4, 0x6}, 0x99873abea0229301?, 0x0?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 182 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010c38a8?, 0x3c?, 0xc0010c38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066a2000, 0x2d0f7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0f0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc3439c568f92abad?, 0x4ad38caef681d72a?, {0x104da355c, 0x14}, 0x2a284303df5bf8e6?, 0x816567eb32106814?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 183 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 186 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 188 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037f58a8?, 0x3c?, 0xc0037f58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008af0000, 0x2bd7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 190 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037db888?, 0x3c?, 0xc0037db8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006790000, 0x2c2e3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 192 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002761888?, 0x3c?, 0xc0027618b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006278000, 0x2c937}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 196 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c618a8?, 0x3c?, 0xc000c618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d88000, 0x2aedf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x66f66ad030295201?, 0x4e8269c18f707ffb?, {0x104da355c, 0x14}, 0xe245c7bcc1a4860a?, 0x84b09ee8ae152305?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 197 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0006618a8?, 0x3c?, 0xc0006618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005db4000, 0x2b1c8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 202 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037e5888?, 0x3c?, 0xc0037e58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065e0000, 0x2be68}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 205 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 206 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0038a9888?, 0x3c?, 0xc0038a98b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005be0000, 0x2b38c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 208 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0024658a8?, 0x3c?, 0xc0024658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005bb2000, 0x2cf7c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 211 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037f98a8?, 0x3c?, 0xc0037f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006832000, 0x2bf53}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 212 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002463888?, 0x3c?, 0xc0024638b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00619a000, 0x2ac73}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 220 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037eb888?, 0x3c?, 0xc0037eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00624c000, 0x2b2a5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 222 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0037d78a8?, 0x3c?, 0xc0037d78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006a9c000, 0x2c02e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0a0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 223 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010bf888?, 0x3c?, 0xc0010bf8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00685e000, 0x2afee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b327d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0150, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x6af358bcb1d9d13b?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2e2ac2be0e0754ac?, 0x87e6aff85ef86711?, {0x104d95eec, 0x3}, 0x89a21b1236da5645?, 0x3e6436d15c2479ba?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+        
+        goroutine 234 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2120, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xa8db55a668ba35ab?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf9a0445d45b635f5?, 0xea709bcf68bb8ea7?, {0x104d95edd, 0x3}, 0x29bab3ca1f705044?, 0xf0edf6feb98874d2?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c5f8a8?, 0x3c?, 0xc000c5f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008ac0000, 0x2f9a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x591de6f93f64200f?, 0xfa2c477206aeb67b?, {0x104da355c, 0x14}, 0xff81388f0b7a5605?, 0x488c027beda67b6c?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 125 [select]:
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20.1(0xc0024189c0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4079 +0xac
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4214 +0x21c
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 137 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 232 [semacquire]:
+        runtime.Stack({0xc00a2be000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 95 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 214 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 153 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 217 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 88 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 101 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22060, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x70fa3173731929d7?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 69 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 70 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 71 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 72 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 77 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 80 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 81 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 82 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 83 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 86 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 87 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 89 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 91 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+--
+        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 93 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 94 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 97 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 98 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 99 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 100 [semacquire]:
+        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 105 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 106 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 109 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 112 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 136 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 138 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 141 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 147 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 149 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 152 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 154 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 156 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 157 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 158 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 159 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 160 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 161 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 179 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 180 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 184 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 185 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 187 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 189 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 191 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 193 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 194 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 195 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 198 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 200 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 201 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 204 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 207 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 209 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 210 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 213 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+        
+        goroutine 215 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+        
+        goroutine 216 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+        
+        goroutine 218 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+        
+        goroutine 219 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+        
+        goroutine 221 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 224 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+        
+        goroutine 225 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+        
+        goroutine 226 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+        
+        goroutine 227 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+        
+        goroutine 228 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+        
+        goroutine 231 [semacquire]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+--
+        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+        
+        goroutine 236 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+        
+        goroutine 237 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+        
+        goroutine 238 [semacquire]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007754000, 0x13996}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003920180, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007754000, 0x13996}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003920180, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007f7e000, 0x13a08}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228ad20, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003905a80, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006346000, 0x142a8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284b70, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        time.Time.AppendFormat({0x15d3813b6?, 0xc00037e900?, 0x1055c42e0?}, {0xc0030cfa58, 0x0, 0x40}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:630 +0x1c0
+        time.Time.Format({0xc0030cfaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
+        	/Users/jekamas/go/go1.19.2/src/time/format.go:608 +0xa8
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x13f4c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0af0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228b9f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006bba000, 0x1469f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5720, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003984c40, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 67 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x13f4c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0af0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228b9f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:81 +0x7c
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006eb6000, 0x14095}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a13b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be57c0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fe0000, 0x1423a}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a1400, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039c8cc0, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00738e000, 0x14122}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222edc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1450, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00738e000, 0x14122}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222edc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1450, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 1 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:81 +0x7c
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007856000, 0x13fa8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bfed80, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be5b80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5b80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1cc0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+--
+        sync.poolRaceAddr(...)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:89
+        sync.(*Pool).Put(0x1a?, {0x1050d3be0, 0xc001085790})
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:104 +0x64
+        fmt.(*pp).free(0xc001085790)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:161 +0x130
+        fmt.Fprintf({0x1050f5f60, 0xc0046977a0}, {0x104d98aab, 0x7}, {0xc0016c38f8, 0x2, 0x2})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:206 +0xac
+        testing.(*common).decorate(0xc0004704e0?, {0xc007856000, 0x13fa8}, 0xc007856000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:671 +0x1e8
+        testing.(*common).logDepth(0xc0004704e0, {0xc007856000, 0x13fa8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ef50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bfed80, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00788a000, 0x14093}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5b80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1cc0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007c7c000, 0x14295}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003965a80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive, 2 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007c7c000, 0x14295}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003965a80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive, 2 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007c7c000, 0x14295}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003965a80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive, 2 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0081ac000, 0x142ea}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f810, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b1e1c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008182000, 0x13f54}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee730, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f400, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 2 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008894000, 0x1401f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f860, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 2 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008894000, 0x1401f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f860, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 2 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005e2c000, 0x1408f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030b01e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b1ea80, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005e2c000, 0x1408f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030b01e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376a440, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005e2c000, 0x1408f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030b01e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc005e62000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006256000, 0x13fa8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222eff0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [runnable]:
+        strings.(*Builder).WriteString(0xc0046772a0, {0xc00622c9d6, 0x27})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc00622a000, 0x1423e}, 0xc00622a000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006636000, 0x13e4b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33c70, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee870, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006636000, 0x13e4b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33c70, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee870, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006aa2000, 0x13ebb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308a50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230d530, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        github.com/ethereum/go-ethereum/common.NowMilliseconds()
+        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f0e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006aa2000, 0x13ebb}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308a50, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230d530, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308af0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308af0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f0e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006f00000, 0x14110}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002309130, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944100, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 67 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006eae000, 0x14094}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023090e0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002409ea0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007346000, 0x14018}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002309270, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222fa90, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc000f88c70, {0xc007310000, 0x14275})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b8000, 0x14539}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b180, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228aaf0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077b8000, 0x14539}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b180, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228aaf0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007c76000, 0x14037}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b270, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003984600, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        strings.(*Builder).WriteString(0xc004682860, {0xc007bdc295, 0x3d})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
+        testing.(*common).decorate(0xc0004704e0?, {0xc007bd6000, 0x13dd4}, 0xc007bd6000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007bd6000, 0x13dd4}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007cf8000, 0x14125}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002309b80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bef950, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 3 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004564000, 0x13dd3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d70, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a52000, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0045a4000, 0x1430f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0e10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c820, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039c8700, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004564000, 0x13dd3}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d70, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a52000, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [semacquire]:
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0045a4000, 0x1430f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0e10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c820, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a52080, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005dd2000, 0x13e48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a53140, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc00143d080, {0x1051f2553, 0xf})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+        fmt.(*fmt).fmtS(0xc00143d080, {0x1051f2553, 0xf})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:359 +0x7c
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005dd2000, 0x13e48}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a53140, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        strings.Index({0xc005dc3311, 0xeac3}, {0x104f92078, 0x1})
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
+        strings.genSplit({0xc005dbe000, 0x13dd4}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
+        strings.Split(...)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005e82000, 0x1413f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cdc0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003920d00, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive, 4 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006694000, 0x13e4c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a0ed80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+        
+        goroutine 67 [chan receive, 4 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006aba000, 0x14095}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b180, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3d860, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b1e780, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006eee000, 0x140b0}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408690, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003921680, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [runnable]:
+        fmt.(*buffer).writeString(...)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
+        fmt.(*fmt).padString(0xc000e5b150, {0xc006f04000, 0x14262})
+        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007374000, 0x143ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376af40, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [semacquire]:
+        runtime.Stack({0xc007338000, 0x10000, 0x10000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007374000, 0x143ef}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408870, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376af40, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 67 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007348000, 0x14021}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408820, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b33090, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00783a000, 0x14016}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b900, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228b770, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408b90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408b90, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00828c000, 0x1430b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222eaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039a6d00, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [runnable]:
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea540, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008258000, 0x13fca}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002408e10, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00828c000, 0x1430b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222eaa0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039a6d00, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 67 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc008258000, 0x13fca}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002408e10, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004608000, 0x13e63}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003090040, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 67 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+--
+        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004608000, 0x13e63}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003090040, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+        
+        goroutine 66 [runnable]:
+        time.(*Location).lookup(0x1055c42e0, 0x6368ec9b)
+        	/Users/jekamas/go/go1.19.2/src/time/zoneinfo.go:124 +0x5c4
+        time.Time.locabs({0xc0d25906d927b280, 0x5677155c75, 0x1055c42e0})
+        	/Users/jekamas/go/go1.19.2/src/time/time.go:472 +0x178
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc004bd8000, 0x13dd9}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e4b0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002408000, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 5 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ed6000, 0x13f2f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee5a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944580, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        strings.Index({0xc005ea1f62, 0xe0b7}, {0x104f92078, 0x1})
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
+        strings.genSplit({0xc005e9c000, 0x14019}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
+        strings.Split(...)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005ed6000, 0x13f2f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee5a0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944580, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        strings.Index({0xc005eae13e, 0x1edb}, {0x104f92078, 0x1})
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
+        strings.genSplit({0xc005e9c000, 0x14019}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
+        strings.Split(...)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006fd4000, 0x13fa6}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004befb30, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a11d0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000034e10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000034e10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00700e000, 0x14396}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5180, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f8b0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 6 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00742c000, 0x14018}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376a180, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        strings.Index({0xc0073ef208, 0x4e87}, {0x104f92078, 0x1})
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
+        strings.genSplit({0xc0073e0000, 0x1408f}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
+        strings.Split(...)
+        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
+--
+        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00742c000, 0x14018}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376a180, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+        
+        goroutine 63 [runnable]:
+        strings.(*Builder).WriteString(0xc004682300, {0x104d9af36, 0x9})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
+        testing.(*common).decorate(0xc0004704e0?, {0xc0073e0000, 0x1408f}, 0xc0073e0000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073e0000, 0x1408f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007cc0000, 0x13e13}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be5c20, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007cc0000, 0x13e13}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be5c20, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007cc0000, 0x13e13}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be5c20, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00459c000, 0x1401d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c5f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00459c000, 0x1401d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c5f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc005e62000, 0x1401c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e10, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3cc30, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006228000, 0x1401f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006228000, 0x1401f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006228000, 0x1401f}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33310, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 7 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066bc000, 0x1423c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002409b80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308cd0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0066bc000, 0x1423c}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002409b80, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308cd0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.(*Pool).pin(0x1055aa560)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:198 +0xcc
+        sync.(*Pool).Put(0x1055aa560?, {0x1050d3be0, 0xc0019a7860})
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:107 +0xa0
+        fmt.(*pp).free(0xc0019a7860)
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:161 +0x130
+        fmt.Fprintf({0x1050f5f60, 0xc004683600}, {0x104d98aab, 0x7}, {0xc0010e98d8, 0x2, 0x2})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:206 +0xac
+        testing.(*common).decorate(0xc0004704e0?, {0xc006a12000, 0x14092}, 0xc006a12000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:671 +0x1e8
+        testing.(*common).logDepth(0xc0004704e0, {0xc006a12000, 0x14092}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3df40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b33540, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ac4000, 0x1411d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b336d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002409c20, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003905080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006ac4000, 0x1411d}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b336d0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002409c20, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [runnable]:
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003905040, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
+        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e7c000, 0x13e4b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33db0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309590, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e7c000, 0x13e4b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33db0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309590, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc006e7c000, 0x13e4b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33db0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309590, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0073aa000, 0x142b8}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ebe0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a0cd0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 66 [runnable]:
+        strings.(*Builder).WriteString(0xc004676060, {0xc0072b17ee, 0x3b})
+        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
+        testing.(*common).decorate(0xc0004704e0?, {0xc0072ae000, 0x13e4a}, 0xc0072ae000?)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc007396000, 0x13e4b}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0eb0, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222e0f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077d8000, 0x14093}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ee60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309d60, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc0077d8000, 0x14093}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ee60, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309d60, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 8 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.poolRaceAddr(...)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:89
+        sync.(*Pool).Get(0x1055aa560)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:147 +0xdc
+        fmt.newPrinter()
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:137 +0x2c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000034b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:218 +0x38
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000034b40, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee4b0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
+        
+        goroutine 64 [semacquire]:
+        runtime.Stack({0xc007c74000, 0x20000, 0x20000}, 0x1)
+        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
+        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
+        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
+--
+        sync.(*Pool).pin(0x1055aa560)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:198 +0xcc
+        sync.(*Pool).Get(0x1055aa560)
+        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:131 +0x34
+        fmt.newPrinter()
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:137 +0x2c
+        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:218 +0x38
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 9 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00890e000, 0x13dd7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 9 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00890e000, 0x13dd7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 9 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+--
+        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
+        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
+        sync.(*Mutex).lockSlow(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
+        sync.(*Mutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
+        sync.(*RWMutex).Lock(0xc0004704e0)
+        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
+        testing.(*common).logDepth(0xc0004704e0, {0xc00890e000, 0x13dd7}, 0x3)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
+        testing.(*common).log(...)
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
+        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
+        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
+        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
+        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
+        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
+        
+        goroutine 79 [chan receive, 9 minutes]:
+        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+        created by github.com/ethereum/go-ethereum/core.apiWithMining
+        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
diff --git a/test1.txt b/test1.txt
new file mode 100644
index 0000000000..1de0dab433
--- /dev/null
+++ b/test1.txt
@@ -0,0 +1,5602 @@
+GODEBUG=cgocheck=0 go test -buildvcs=false -ldflags "-X github.com/ethereum/go-ethereum/params.GitCommit=8de32f470c226fe4186211090e49338955205d80 -X github.com/ethereum/go-ethereum/params.GitBranch=shivam/txpool-tracing-optimizations -X github.com/ethereum/go-ethereum/params.GitTag=v0.2.17" -p 1 -run=TestPoolMiningDataRaces --timeout 10m -race -v ./core/
+=== RUN   TestPoolMiningDataRaces
+=== RUN   TestPoolMiningDataRaces/size_1
+    tx_pool_test.go:3866: [12:07:01.110] starting goroutines
+    tx_pool_test.go:4116: [12:07:01.110] starting AddRemotes
+    tx_pool_test.go:4116: [12:07:01.110] starting AddRemotesSync
+    tx_pool_test.go:3873: [12:07:01.110] starting AddLocal(s)
+    tx_pool_test.go:4136: [12:07:01.110] starting AddRemoteSync
+    tx_pool_test.go:4091: [12:07:01.111] before the first propagated transaction
+    tx_pool_test.go:4093: [12:07:01.111] after the first propagated transaction
+    tx_pool_test.go:4136: [12:07:01.110] starting AddRemote
+    tx_pool_test.go:3722: [12:07:02.115] mining block. block 0. total 400: pending 18(added 0), local 1(added 400), queued 56
+    tx_pool_test.go:3722: [12:07:03.114] mining block. block 1. total 400: pending 4(added 400), local 0(added 0), queued 140
+    tx_pool_test.go:3722: [12:07:04.116] mining block. block 2. total 400: pending 3(added 400), local 0(added 0), queued 205
+    tx_pool_test.go:3722: [12:07:05.116] mining block. block 3. total 400: pending 2(added 400), local 0(added 0), queued 276
+    tx_pool_test.go:3722: [12:07:06.114] mining block. block 4. total 400: pending 1(added 400), local 0(added 0), queued 348
+    tx_pool_test.go:3722: [12:07:07.115] mining block. block 5. total 0: pending 0(added 0), local 0(added 0), queued 415
+    tx_pool_test.go:3722: [12:07:08.113] mining block. block 6. total 0: pending 0(added 0), local 0(added 0), queued 483
+    tx_pool_test.go:3722: [12:07:09.113] mining block. block 7. total 0: pending 0(added 0), local 0(added 0), queued 552
+    tx_pool_test.go:3722: [12:07:10.113] mining block. block 8. total 0: pending 0(added 0), local 0(added 0), queued 620
+    tx_pool_test.go:3722: [12:07:11.113] mining block. block 9. total 0: pending 0(added 0), local 0(added 0), queued 689
+    tx_pool_test.go:3722: [12:07:12.113] mining block. block 10. total 0: pending 0(added 0), local 0(added 0), queued 758
+    tx_pool_test.go:3722: [12:07:13.113] mining block. block 11. total 0: pending 0(added 0), local 0(added 0), queued 829
+    tx_pool_test.go:3722: [12:07:14.113] mining block. block 12. total 0: pending 0(added 0), local 0(added 0), queued 900
+    tx_pool_test.go:3722: [12:07:15.114] mining block. block 13. total 0: pending 0(added 0), local 0(added 0), queued 968
+    tx_pool_test.go:3722: [12:07:16.114] mining block. block 14. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:17.113] mining block. block 15. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:18.115] mining block. block 16. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:19.114] mining block. block 17. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:20.116] mining block. block 18. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:21.114] mining block. block 19. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:22.118] mining block. block 20. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:23.112] mining block. block 21. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:24.116] mining block. block 22. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:25.114] mining block. block 23. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:26.114] mining block. block 24. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:27.118] mining block. block 25. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:28.114] mining block. block 26. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:29.113] mining block. block 27. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:30.114] mining block. block 28. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:31.114] mining block. block 29. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:32.114] mining block. block 30. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:33.114] mining block. block 31. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:34.117] mining block. block 32. total 0: pending 0(added 0), local 0(added 0), queued 1025
+    tx_pool_test.go:3722: [12:07:35.112] mining block. block 33. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:36.113] mining block. block 34. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:37.112] mining block. block 35. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:38.113] mining block. block 36. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:39.113] mining block. block 37. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:40.112] mining block. block 38. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:41.112] mining block. block 39. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:42.112] mining block. block 40. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:43.112] mining block. block 41. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:44.112] mining block. block 42. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:45.115] mining block. block 43. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:46.112] mining block. block 44. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:47.114] mining block. block 45. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:48.113] mining block. block 46. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:49.113] mining block. block 47. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:50.115] mining block. block 48. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:51.112] mining block. block 49. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:52.113] mining block. block 50. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:53.113] mining block. block 51. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:54.113] mining block. block 52. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:55.112] mining block. block 53. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:56.113] mining block. block 54. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:57.112] mining block. block 55. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:58.113] mining block. block 56. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:07:59.113] mining block. block 57. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:00.112] mining block. block 58. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:01.113] mining block. block 59. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:02.112] mining block. block 60. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:03.112] mining block. block 61. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:04.112] mining block. block 62. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:05.112] mining block. block 63. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:06.113] mining block. block 64. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:07.112] mining block. block 65. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:08.112] mining block. block 66. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:09.113] mining block. block 67. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:10.113] mining block. block 68. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:11.113] mining block. block 69. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:12.112] mining block. block 70. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:13.112] mining block. block 71. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:14.113] mining block. block 72. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:15.113] mining block. block 73. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:16.112] mining block. block 74. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:17.113] mining block. block 75. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:18.112] mining block. block 76. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:19.112] mining block. block 77. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:20.112] mining block. block 78. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:21.112] mining block. block 79. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:22.112] mining block. block 80. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:23.111] mining block. block 81. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:24.112] mining block. block 82. total 0: pending 0(added 0), local 0(added 0), queued 1024
+    tx_pool_test.go:3722: [12:08:25.112] mining block. block 83. total 0: pending 0(added 0), local 0(added 0), queued 1035
+    tx_pool_test.go:3722: [12:08:26.112] mining block. block 84. total 0: pending 0(added 0), local 0(added 0), queued 1050
+    tx_pool_test.go:3722: [12:08:27.112] mining block. block 85. total 0: pending 0(added 0), local 0(added 0), queued 1063
+    tx_pool_test.go:3722: [12:08:28.112] mining block. block 86. total 0: pending 0(added 0), local 0(added 0), queued 1075
+    tx_pool_test.go:3722: [12:08:29.112] mining block. block 87. total 0: pending 0(added 0), local 0(added 0), queued 1087
+    tx_pool_test.go:3722: [12:08:30.112] mining block. block 88. total 0: pending 0(added 0), local 0(added 0), queued 1099
+    tx_pool_test.go:3722: [12:08:31.112] mining block. block 89. total 0: pending 0(added 0), local 0(added 0), queued 1113
+    tx_pool_test.go:3722: [12:08:32.112] mining block. block 90. total 0: pending 0(added 0), local 0(added 0), queued 1128
+    tx_pool_test.go:3722: [12:08:33.112] mining block. block 91. total 0: pending 0(added 0), local 0(added 0), queued 1140
+    tx_pool_test.go:3722: [12:08:34.112] mining block. block 92. total 0: pending 0(added 0), local 0(added 0), queued 1153
+    tx_pool_test.go:3722: [12:08:35.112] mining block. block 93. total 0: pending 0(added 0), local 0(added 0), queued 1166
+    tx_pool_test.go:3722: [12:08:36.111] mining block. block 94. total 0: pending 0(added 0), local 0(added 0), queued 1179
+    tx_pool_test.go:3722: [12:08:37.112] mining block. block 95. total 0: pending 0(added 0), local 0(added 0), queued 1191
+    tx_pool_test.go:3722: [12:08:38.112] mining block. block 96. total 0: pending 0(added 0), local 0(added 0), queued 1204
+    tx_pool_test.go:3722: [12:08:39.112] mining block. block 97. total 0: pending 0(added 0), local 0(added 0), queued 1217
+    tx_pool_test.go:3722: [12:08:40.111] mining block. block 98. total 0: pending 0(added 0), local 0(added 0), queued 1228
+    tx_pool_test.go:3722: [12:08:41.111] mining block. block 99. total 0: pending 0(added 0), local 0(added 0), queued 1239
+    tx_pool_test.go:3722: [12:08:42.112] mining block. block 100. total 0: pending 0(added 0), local 0(added 0), queued 1252
+    tx_pool_test.go:3722: [12:08:43.112] mining block. block 101. total 0: pending 0(added 0), local 0(added 0), queued 1266
+    tx_pool_test.go:3722: [12:08:44.112] mining block. block 102. total 0: pending 0(added 0), local 0(added 0), queued 1280
+    tx_pool_test.go:3722: [12:08:45.113] mining block. block 103. total 0: pending 0(added 0), local 0(added 0), queued 1293
+    tx_pool_test.go:3722: [12:08:46.113] mining block. block 104. total 0: pending 0(added 0), local 0(added 0), queued 1306
+    tx_pool_test.go:3722: [12:08:47.111] mining block. block 105. total 0: pending 0(added 0), local 0(added 0), queued 1322
+    tx_pool_test.go:3722: [12:08:48.112] mining block. block 106. total 0: pending 0(added 0), local 0(added 0), queued 1336
+    tx_pool_test.go:3722: [12:08:49.112] mining block. block 107. total 0: pending 0(added 0), local 0(added 0), queued 1349
+    tx_pool_test.go:3722: [12:08:50.112] mining block. block 108. total 0: pending 0(added 0), local 0(added 0), queued 1363
+    tx_pool_test.go:3722: [12:08:51.112] mining block. block 109. total 0: pending 0(added 0), local 0(added 0), queued 1377
+    tx_pool_test.go:3722: [12:08:52.112] mining block. block 110. total 0: pending 0(added 0), local 0(added 0), queued 1390
+    tx_pool_test.go:3722: [12:08:53.112] mining block. block 111. total 0: pending 0(added 0), local 0(added 0), queued 1404
+    tx_pool_test.go:3722: [12:08:54.112] mining block. block 112. total 0: pending 0(added 0), local 0(added 0), queued 1417
+    tx_pool_test.go:3722: [12:08:55.112] mining block. block 113. total 0: pending 0(added 0), local 0(added 0), queued 1430
+    tx_pool_test.go:3722: [12:08:56.112] mining block. block 114. total 0: pending 0(added 0), local 0(added 0), queued 1443
+    tx_pool_test.go:3722: [12:08:57.112] mining block. block 115. total 0: pending 0(added 0), local 0(added 0), queued 1455
+    tx_pool_test.go:3722: [12:08:58.112] mining block. block 116. total 0: pending 0(added 0), local 0(added 0), queued 1468
+    tx_pool_test.go:3722: [12:08:59.112] mining block. block 117. total 0: pending 0(added 0), local 0(added 0), queued 1481
+    tx_pool_test.go:3722: [12:09:00.112] mining block. block 118. total 0: pending 0(added 0), local 0(added 0), queued 1495
+    tx_pool_test.go:3722: [12:09:01.112] mining block. block 119. total 0: pending 0(added 0), local 0(added 0), queued 1508
+    tx_pool_test.go:3722: [12:09:02.112] mining block. block 120. total 0: pending 0(added 0), local 0(added 0), queued 1522
+    tx_pool_test.go:3722: [12:09:03.112] mining block. block 121. total 0: pending 0(added 0), local 0(added 0), queued 1533
+    tx_pool_test.go:3722: [12:09:04.112] mining block. block 122. total 0: pending 0(added 0), local 0(added 0), queued 1546
+    tx_pool_test.go:3722: [12:09:05.112] mining block. block 123. total 0: pending 0(added 0), local 0(added 0), queued 1558
+    tx_pool_test.go:3722: [12:09:06.112] mining block. block 124. total 0: pending 0(added 0), local 0(added 0), queued 1569
+    tx_pool_test.go:3722: [12:09:07.111] mining block. block 125. total 0: pending 0(added 0), local 0(added 0), queued 1584
+    tx_pool_test.go:3722: [12:09:08.112] mining block. block 126. total 0: pending 0(added 0), local 0(added 0), queued 1596
+    tx_pool_test.go:3722: [12:09:09.112] mining block. block 127. total 0: pending 0(added 0), local 0(added 0), queued 1608
+    tx_pool_test.go:3722: [12:09:10.112] mining block. block 128. total 0: pending 0(added 0), local 0(added 0), queued 1623
+    tx_pool_test.go:3722: [12:09:11.112] mining block. block 129. total 0: pending 0(added 0), local 0(added 0), queued 1636
+    tx_pool_test.go:3722: [12:09:12.112] mining block. block 130. total 0: pending 0(added 0), local 0(added 0), queued 1649
+    tx_pool_test.go:3722: [12:09:13.111] mining block. block 131. total 0: pending 0(added 0), local 0(added 0), queued 1663
+    tx_pool_test.go:3722: [12:09:14.111] mining block. block 132. total 0: pending 0(added 0), local 0(added 0), queued 1675
+    tx_pool_test.go:3722: [12:09:15.112] mining block. block 133. total 0: pending 0(added 0), local 0(added 0), queued 1688
+    tx_pool_test.go:3722: [12:09:16.113] mining block. block 134. total 0: pending 0(added 0), local 0(added 0), queued 1701
+    tx_pool_test.go:3722: [12:09:17.112] mining block. block 135. total 0: pending 0(added 0), local 0(added 0), queued 1713
+    tx_pool_test.go:3722: [12:09:18.112] mining block. block 136. total 0: pending 0(added 0), local 0(added 0), queued 1726
+    tx_pool_test.go:3722: [12:09:19.112] mining block. block 137. total 0: pending 0(added 0), local 0(added 0), queued 1741
+    tx_pool_test.go:3722: [12:09:20.111] mining block. block 138. total 0: pending 0(added 0), local 0(added 0), queued 1752
+    tx_pool_test.go:3722: [12:09:21.111] mining block. block 139. total 0: pending 0(added 0), local 0(added 0), queued 1764
+    tx_pool_test.go:3722: [12:09:22.111] mining block. block 140. total 0: pending 0(added 0), local 0(added 0), queued 1777
+    tx_pool_test.go:3722: [12:09:23.111] mining block. block 141. total 0: pending 0(added 0), local 0(added 0), queued 1791
+    tx_pool_test.go:3722: [12:09:24.112] mining block. block 142. total 0: pending 0(added 0), local 0(added 0), queued 1803
+    tx_pool_test.go:3722: [12:09:25.112] mining block. block 143. total 0: pending 0(added 0), local 0(added 0), queued 1819
+    tx_pool_test.go:3722: [12:09:26.112] mining block. block 144. total 0: pending 0(added 0), local 0(added 0), queued 1834
+    tx_pool_test.go:3722: [12:09:27.111] mining block. block 145. total 0: pending 0(added 0), local 0(added 0), queued 1847
+    tx_pool_test.go:3722: [12:09:28.112] mining block. block 146. total 0: pending 0(added 0), local 0(added 0), queued 1860
+    tx_pool_test.go:3722: [12:09:29.111] mining block. block 147. total 0: pending 0(added 0), local 0(added 0), queued 1873
+    tx_pool_test.go:3722: [12:09:30.112] mining block. block 148. total 0: pending 0(added 0), local 0(added 0), queued 1887
+    tx_pool_test.go:3722: [12:09:31.112] mining block. block 149. total 0: pending 0(added 0), local 0(added 0), queued 1899
+    tx_pool_test.go:3722: [12:09:32.111] mining block. block 150. total 0: pending 0(added 0), local 0(added 0), queued 1912
+    tx_pool_test.go:3722: [12:09:33.112] mining block. block 151. total 0: pending 0(added 0), local 0(added 0), queued 1923
+    tx_pool_test.go:3722: [12:09:34.112] mining block. block 152. total 0: pending 0(added 0), local 0(added 0), queued 1936
+    tx_pool_test.go:3722: [12:09:35.112] mining block. block 153. total 0: pending 0(added 0), local 0(added 0), queued 1950
+    tx_pool_test.go:3722: [12:09:36.112] mining block. block 154. total 0: pending 0(added 0), local 0(added 0), queued 1962
+    tx_pool_test.go:3722: [12:09:37.112] mining block. block 155. total 0: pending 0(added 0), local 0(added 0), queued 1974
+    tx_pool_test.go:3722: [12:09:38.112] mining block. block 156. total 0: pending 0(added 0), local 0(added 0), queued 1984
+    tx_pool_test.go:3722: [12:09:39.112] mining block. block 157. total 0: pending 0(added 0), local 0(added 0), queued 1998
+    tx_pool_test.go:3722: [12:09:40.112] mining block. block 158. total 0: pending 0(added 0), local 0(added 0), queued 2012
+    tx_pool_test.go:3722: [12:09:41.112] mining block. block 159. total 0: pending 0(added 0), local 0(added 0), queued 2027
+    tx_pool_test.go:3722: [12:09:42.112] mining block. block 160. total 0: pending 0(added 0), local 0(added 0), queued 2040
+    tx_pool_test.go:3722: [12:09:43.112] mining block. block 161. total 0: pending 0(added 0), local 0(added 0), queued 2054
+    tx_pool_test.go:3722: [12:09:44.112] mining block. block 162. total 0: pending 0(added 0), local 0(added 0), queued 2067
+    tx_pool_test.go:3722: [12:09:45.112] mining block. block 163. total 0: pending 0(added 0), local 0(added 0), queued 2081
+    tx_pool_test.go:3722: [12:09:46.112] mining block. block 164. total 0: pending 0(added 0), local 0(added 0), queued 2094
+    tx_pool_test.go:3722: [12:09:47.111] mining block. block 165. total 0: pending 0(added 0), local 0(added 0), queued 2108
+    tx_pool_test.go:3722: [12:09:48.112] mining block. block 166. total 0: pending 0(added 0), local 0(added 0), queued 2121
+    tx_pool_test.go:3722: [12:09:49.112] mining block. block 167. total 0: pending 0(added 0), local 0(added 0), queued 2135
+    tx_pool_test.go:3722: [12:09:50.112] mining block. block 168. total 0: pending 0(added 0), local 0(added 0), queued 2148
+    tx_pool_test.go:3722: [12:09:51.112] mining block. block 169. total 0: pending 0(added 0), local 0(added 0), queued 2160
+    tx_pool_test.go:3722: [12:09:52.112] mining block. block 170. total 0: pending 0(added 0), local 0(added 0), queued 2176
+    tx_pool_test.go:3722: [12:09:53.112] mining block. block 171. total 0: pending 0(added 0), local 0(added 0), queued 2188
+    tx_pool_test.go:3722: [12:09:54.111] mining block. block 172. total 0: pending 0(added 0), local 0(added 0), queued 2202
+    tx_pool_test.go:3722: [12:09:55.112] mining block. block 173. total 0: pending 0(added 0), local 0(added 0), queued 2214
+    tx_pool_test.go:3722: [12:09:56.111] mining block. block 174. total 0: pending 0(added 0), local 0(added 0), queued 2227
+    tx_pool_test.go:3722: [12:09:57.112] mining block. block 175. total 0: pending 0(added 0), local 0(added 0), queued 2240
+    tx_pool_test.go:3722: [12:09:58.112] mining block. block 176. total 0: pending 0(added 0), local 0(added 0), queued 2252
+    tx_pool_test.go:3722: [12:09:59.112] mining block. block 177. total 0: pending 0(added 0), local 0(added 0), queued 2265
+    tx_pool_test.go:3722: [12:10:00.111] mining block. block 178. total 0: pending 0(added 0), local 0(added 0), queued 2279
+    tx_pool_test.go:3722: [12:10:01.111] mining block. block 179. total 0: pending 0(added 0), local 0(added 0), queued 2290
+    tx_pool_test.go:3722: [12:10:02.111] mining block. block 180. total 0: pending 0(added 0), local 0(added 0), queued 2303
+    tx_pool_test.go:3722: [12:10:03.112] mining block. block 181. total 0: pending 0(added 0), local 0(added 0), queued 2314
+    tx_pool_test.go:3722: [12:10:04.112] mining block. block 182. total 0: pending 0(added 0), local 0(added 0), queued 2327
+    tx_pool_test.go:3722: [12:10:05.112] mining block. block 183. total 0: pending 0(added 0), local 0(added 0), queued 2341
+    tx_pool_test.go:3722: [12:10:06.112] mining block. block 184. total 0: pending 0(added 0), local 0(added 0), queued 2353
+    tx_pool_test.go:3722: [12:10:07.111] mining block. block 185. total 0: pending 0(added 0), local 0(added 0), queued 2365
+    tx_pool_test.go:3722: [12:10:08.112] mining block. block 186. total 0: pending 0(added 0), local 0(added 0), queued 2380
+    tx_pool_test.go:3722: [12:10:09.112] mining block. block 187. total 0: pending 0(added 0), local 0(added 0), queued 2392
+    tx_pool_test.go:3722: [12:10:10.113] mining block. block 188. total 0: pending 0(added 0), local 0(added 0), queued 2406
+    tx_pool_test.go:3722: [12:10:11.112] mining block. block 189. total 0: pending 0(added 0), local 0(added 0), queued 2421
+    tx_pool_test.go:3722: [12:10:12.111] mining block. block 190. total 0: pending 0(added 0), local 0(added 0), queued 2434
+    tx_pool_test.go:3722: [12:10:13.112] mining block. block 191. total 0: pending 0(added 0), local 0(added 0), queued 2449
+    tx_pool_test.go:3722: [12:10:14.112] mining block. block 192. total 0: pending 0(added 0), local 0(added 0), queued 2462
+    tx_pool_test.go:3722: [12:10:15.111] mining block. block 193. total 0: pending 0(added 0), local 0(added 0), queued 2476
+    tx_pool_test.go:3722: [12:10:16.112] mining block. block 194. total 0: pending 0(added 0), local 0(added 0), queued 2490
+    tx_pool_test.go:3722: [12:10:17.111] mining block. block 195. total 0: pending 0(added 0), local 0(added 0), queued 2502
+    tx_pool_test.go:3722: [12:10:18.111] mining block. block 196. total 0: pending 0(added 0), local 0(added 0), queued 2515
+    tx_pool_test.go:3722: [12:10:19.112] mining block. block 197. total 0: pending 0(added 0), local 0(added 0), queued 2525
+    tx_pool_test.go:3722: [12:10:20.113] mining block. block 198. total 0: pending 0(added 0), local 0(added 0), queued 2537
+    tx_pool_test.go:3722: [12:10:21.112] mining block. block 199. total 0: pending 0(added 0), local 0(added 0), queued 2549
+    tx_pool_test.go:3722: [12:10:22.111] mining block. block 200. total 0: pending 0(added 0), local 0(added 0), queued 2562
+    tx_pool_test.go:3722: [12:10:23.111] mining block. block 201. total 0: pending 0(added 0), local 0(added 0), queued 2574
+    tx_pool_test.go:3722: [12:10:24.111] mining block. block 202. total 0: pending 0(added 0), local 0(added 0), queued 2587
+    tx_pool_test.go:3722: [12:10:25.112] mining block. block 203. total 0: pending 0(added 0), local 0(added 0), queued 2601
+    tx_pool_test.go:3722: [12:10:26.112] mining block. block 204. total 0: pending 0(added 0), local 0(added 0), queued 2615
+    tx_pool_test.go:3722: [12:10:27.112] mining block. block 205. total 0: pending 0(added 0), local 0(added 0), queued 2626
+    tx_pool_test.go:3722: [12:10:28.111] mining block. block 206. total 0: pending 0(added 0), local 0(added 0), queued 2640
+    tx_pool_test.go:3722: [12:10:29.111] mining block. block 207. total 0: pending 0(added 0), local 0(added 0), queued 2654
+    tx_pool_test.go:3722: [12:10:30.112] mining block. block 208. total 0: pending 0(added 0), local 0(added 0), queued 2665
+    tx_pool_test.go:3722: [12:10:31.111] mining block. block 209. total 0: pending 0(added 0), local 0(added 0), queued 2676
+    tx_pool_test.go:3722: [12:10:32.111] mining block. block 210. total 0: pending 0(added 0), local 0(added 0), queued 2689
+    tx_pool_test.go:3722: [12:10:33.111] mining block. block 211. total 0: pending 0(added 0), local 0(added 0), queued 2702
+    tx_pool_test.go:3722: [12:10:34.111] mining block. block 212. total 0: pending 0(added 0), local 0(added 0), queued 2716
+    tx_pool_test.go:3722: [12:10:35.112] mining block. block 213. total 0: pending 0(added 0), local 0(added 0), queued 2728
+    tx_pool_test.go:3722: [12:10:36.111] mining block. block 214. total 0: pending 0(added 0), local 0(added 0), queued 2741
+    tx_pool_test.go:3722: [12:10:37.112] mining block. block 215. total 0: pending 0(added 0), local 0(added 0), queued 2754
+    tx_pool_test.go:3722: [12:10:38.111] mining block. block 216. total 0: pending 0(added 0), local 0(added 0), queued 2767
+    tx_pool_test.go:3722: [12:10:39.112] mining block. block 217. total 0: pending 0(added 0), local 0(added 0), queued 2781
+    tx_pool_test.go:3722: [12:10:40.111] mining block. block 218. total 0: pending 0(added 0), local 0(added 0), queued 2793
+    tx_pool_test.go:3722: [12:10:41.111] mining block. block 219. total 0: pending 0(added 0), local 0(added 0), queued 2806
+    tx_pool_test.go:3722: [12:10:42.112] mining block. block 220. total 0: pending 0(added 0), local 0(added 0), queued 2819
+    tx_pool_test.go:3722: [12:10:43.111] mining block. block 221. total 0: pending 0(added 0), local 0(added 0), queued 2832
+    tx_pool_test.go:3722: [12:10:44.112] mining block. block 222. total 0: pending 0(added 0), local 0(added 0), queued 2847
+    tx_pool_test.go:3722: [12:10:45.112] mining block. block 223. total 0: pending 0(added 0), local 0(added 0), queued 2859
+    tx_pool_test.go:3722: [12:10:46.112] mining block. block 224. total 0: pending 0(added 0), local 0(added 0), queued 2871
+    tx_pool_test.go:3722: [12:10:47.112] mining block. block 225. total 0: pending 0(added 0), local 0(added 0), queued 2885
+    tx_pool_test.go:3722: [12:10:48.111] mining block. block 226. total 0: pending 0(added 0), local 0(added 0), queued 2900
+    tx_pool_test.go:3722: [12:10:49.112] mining block. block 227. total 0: pending 0(added 0), local 0(added 0), queued 2913
+    tx_pool_test.go:3722: [12:10:50.112] mining block. block 228. total 0: pending 0(added 0), local 0(added 0), queued 2926
+    tx_pool_test.go:3722: [12:10:51.111] mining block. block 229. total 0: pending 0(added 0), local 0(added 0), queued 2937
+    tx_pool_test.go:3722: [12:10:52.112] mining block. block 230. total 0: pending 0(added 0), local 0(added 0), queued 2949
+    tx_pool_test.go:3722: [12:10:53.112] mining block. block 231. total 0: pending 0(added 0), local 0(added 0), queued 2964
+    tx_pool_test.go:3722: [12:10:54.112] mining block. block 232. total 0: pending 0(added 0), local 0(added 0), queued 2977
+    tx_pool_test.go:3722: [12:10:55.112] mining block. block 233. total 0: pending 0(added 0), local 0(added 0), queued 2991
+    tx_pool_test.go:3722: [12:10:56.112] mining block. block 234. total 0: pending 0(added 0), local 0(added 0), queued 3005
+    tx_pool_test.go:3722: [12:10:57.111] mining block. block 235. total 0: pending 0(added 0), local 0(added 0), queued 3018
+    tx_pool_test.go:3722: [12:10:58.111] mining block. block 236. total 0: pending 0(added 0), local 0(added 0), queued 3035
+    tx_pool_test.go:3722: [12:10:59.111] mining block. block 237. total 0: pending 0(added 0), local 0(added 0), queued 3049
+    tx_pool_test.go:3722: [12:11:00.112] mining block. block 238. total 0: pending 0(added 0), local 0(added 0), queued 3065
+    tx_pool_test.go:3722: [12:11:01.111] mining block. block 239. total 0: pending 0(added 0), local 0(added 0), queued 3078
+    tx_pool_test.go:3722: [12:11:02.111] mining block. block 240. total 0: pending 0(added 0), local 0(added 0), queued 3092
+    tx_pool_test.go:3722: [12:11:03.112] mining block. block 241. total 0: pending 0(added 0), local 0(added 0), queued 3107
+    tx_pool_test.go:3722: [12:11:04.114] mining block. block 242. total 0: pending 0(added 0), local 0(added 0), queued 3123
+    tx_pool_test.go:3722: [12:11:05.112] mining block. block 243. total 0: pending 0(added 0), local 0(added 0), queued 3135
+    tx_pool_test.go:3722: [12:11:06.111] mining block. block 244. total 0: pending 0(added 0), local 0(added 0), queued 3148
+    tx_pool_test.go:3722: [12:11:07.112] mining block. block 245. total 0: pending 0(added 0), local 0(added 0), queued 3159
+    tx_pool_test.go:3722: [12:11:08.111] mining block. block 246. total 0: pending 0(added 0), local 0(added 0), queued 3172
+    tx_pool_test.go:3722: [12:11:09.112] mining block. block 247. total 0: pending 0(added 0), local 0(added 0), queued 3187
+    tx_pool_test.go:3722: [12:11:10.112] mining block. block 248. total 0: pending 0(added 0), local 0(added 0), queued 3198
+    tx_pool_test.go:3722: [12:11:11.111] mining block. block 249. total 0: pending 0(added 0), local 0(added 0), queued 3210
+    tx_pool_test.go:3722: [12:11:12.112] mining block. block 250. total 0: pending 0(added 0), local 0(added 0), queued 3221
+    tx_pool_test.go:3722: [12:11:13.113] mining block. block 251. total 0: pending 0(added 0), local 0(added 0), queued 3234
+    tx_pool_test.go:3722: [12:11:14.112] mining block. block 252. total 0: pending 0(added 0), local 0(added 0), queued 3247
+    tx_pool_test.go:3722: [12:11:15.111] mining block. block 253. total 0: pending 0(added 0), local 0(added 0), queued 3258
+    tx_pool_test.go:3722: [12:11:16.112] mining block. block 254. total 0: pending 0(added 0), local 0(added 0), queued 3268
+    tx_pool_test.go:3722: [12:11:17.111] mining block. block 255. total 0: pending 0(added 0), local 0(added 0), queued 3280
+    tx_pool_test.go:3722: [12:11:18.112] mining block. block 256. total 0: pending 0(added 0), local 0(added 0), queued 3294
+    tx_pool_test.go:3722: [12:11:19.111] mining block. block 257. total 0: pending 0(added 0), local 0(added 0), queued 3308
+    tx_pool_test.go:3722: [12:11:20.112] mining block. block 258. total 0: pending 0(added 0), local 0(added 0), queued 3322
+    tx_pool_test.go:3722: [12:11:21.112] mining block. block 259. total 0: pending 0(added 0), local 0(added 0), queued 3334
+    tx_pool_test.go:3722: [12:11:22.111] mining block. block 260. total 0: pending 0(added 0), local 0(added 0), queued 3346
+    tx_pool_test.go:3722: [12:11:23.111] mining block. block 261. total 0: pending 0(added 0), local 0(added 0), queued 3357
+    tx_pool_test.go:3722: [12:11:24.112] mining block. block 262. total 0: pending 0(added 0), local 0(added 0), queued 3371
+    tx_pool_test.go:3722: [12:11:25.112] mining block. block 263. total 0: pending 0(added 0), local 0(added 0), queued 3384
+    tx_pool_test.go:3722: [12:11:26.112] mining block. block 264. total 0: pending 0(added 0), local 0(added 0), queued 3396
+    tx_pool_test.go:3722: [12:11:27.112] mining block. block 265. total 0: pending 0(added 0), local 0(added 0), queued 3408
+    tx_pool_test.go:3722: [12:11:28.112] mining block. block 266. total 0: pending 0(added 0), local 0(added 0), queued 3422
+    tx_pool_test.go:3722: [12:11:29.111] mining block. block 267. total 0: pending 0(added 0), local 0(added 0), queued 3435
+    tx_pool_test.go:3722: [12:11:30.111] mining block. block 268. total 0: pending 0(added 0), local 0(added 0), queued 3447
+    tx_pool_test.go:3722: [12:11:31.112] mining block. block 269. total 0: pending 0(added 0), local 0(added 0), queued 3461
+    tx_pool_test.go:3722: [12:11:32.111] mining block. block 270. total 0: pending 0(added 0), local 0(added 0), queued 3474
+    tx_pool_test.go:3722: [12:11:33.112] mining block. block 271. total 0: pending 0(added 0), local 0(added 0), queued 3486
+    tx_pool_test.go:3722: [12:11:34.111] mining block. block 272. total 0: pending 0(added 0), local 0(added 0), queued 3501
+    tx_pool_test.go:3722: [12:11:35.112] mining block. block 273. total 0: pending 0(added 0), local 0(added 0), queued 3512
+    tx_pool_test.go:3722: [12:11:36.111] mining block. block 274. total 0: pending 0(added 0), local 0(added 0), queued 3525
+    tx_pool_test.go:3722: [12:11:37.111] mining block. block 275. total 0: pending 0(added 0), local 0(added 0), queued 3538
+    tx_pool_test.go:3722: [12:11:38.111] mining block. block 276. total 0: pending 0(added 0), local 0(added 0), queued 3552
+    tx_pool_test.go:3722: [12:11:39.111] mining block. block 277. total 0: pending 0(added 0), local 0(added 0), queued 3566
+    tx_pool_test.go:3722: [12:11:40.111] mining block. block 278. total 0: pending 0(added 0), local 0(added 0), queued 3578
+    tx_pool_test.go:3722: [12:11:41.111] mining block. block 279. total 0: pending 0(added 0), local 0(added 0), queued 3591
+    tx_pool_test.go:3722: [12:11:42.111] mining block. block 280. total 0: pending 0(added 0), local 0(added 0), queued 3604
+    tx_pool_test.go:3722: [12:11:43.111] mining block. block 281. total 0: pending 0(added 0), local 0(added 0), queued 3618
+    tx_pool_test.go:3722: [12:11:44.111] mining block. block 282. total 0: pending 0(added 0), local 0(added 0), queued 3628
+    tx_pool_test.go:3722: [12:11:45.110] mining block. block 283. total 0: pending 0(added 0), local 0(added 0), queued 3642
+    tx_pool_test.go:3722: [12:11:46.112] mining block. block 284. total 0: pending 0(added 0), local 0(added 0), queued 3655
+    tx_pool_test.go:3722: [12:11:47.111] mining block. block 285. total 0: pending 0(added 0), local 0(added 0), queued 3667
+    tx_pool_test.go:3722: [12:11:48.111] mining block. block 286. total 0: pending 0(added 0), local 0(added 0), queued 3682
+    tx_pool_test.go:3722: [12:11:49.111] mining block. block 287. total 0: pending 0(added 0), local 0(added 0), queued 3695
+    tx_pool_test.go:3722: [12:11:50.111] mining block. block 288. total 0: pending 0(added 0), local 0(added 0), queued 3709
+    tx_pool_test.go:3722: [12:11:51.112] mining block. block 289. total 0: pending 0(added 0), local 0(added 0), queued 3721
+    tx_pool_test.go:3722: [12:11:52.111] mining block. block 290. total 0: pending 0(added 0), local 0(added 0), queued 3734
+    tx_pool_test.go:3722: [12:11:53.111] mining block. block 291. total 0: pending 0(added 0), local 0(added 0), queued 3749
+    tx_pool_test.go:3722: [12:11:54.111] mining block. block 292. total 0: pending 0(added 0), local 0(added 0), queued 3762
+    tx_pool_test.go:3722: [12:11:55.112] mining block. block 293. total 0: pending 0(added 0), local 0(added 0), queued 3775
+    tx_pool_test.go:3722: [12:11:56.111] mining block. block 294. total 0: pending 0(added 0), local 0(added 0), queued 3787
+    tx_pool_test.go:3722: [12:11:57.111] mining block. block 295. total 0: pending 0(added 0), local 0(added 0), queued 3801
+    tx_pool_test.go:3722: [12:11:58.111] mining block. block 296. total 0: pending 0(added 0), local 0(added 0), queued 3811
+    tx_pool_test.go:3722: [12:11:59.111] mining block. block 297. total 0: pending 0(added 0), local 0(added 0), queued 3824
+    tx_pool_test.go:3722: [12:12:00.111] mining block. block 298. total 0: pending 0(added 0), local 0(added 0), queued 3839
+    tx_pool_test.go:3722: [12:12:01.111] mining block. block 299. total 0: pending 0(added 0), local 0(added 0), queued 3853
+    tx_pool_test.go:3722: [12:12:02.110] mining block. block 300. total 0: pending 0(added 0), local 0(added 0), queued 3866
+    tx_pool_test.go:3722: [12:12:03.114] mining block. block 301. total 0: pending 0(added 0), local 0(added 0), queued 3879
+    tx_pool_test.go:3722: [12:12:04.111] mining block. block 302. total 0: pending 0(added 0), local 0(added 0), queued 3893
+    tx_pool_test.go:3722: [12:12:05.111] mining block. block 303. total 0: pending 0(added 0), local 0(added 0), queued 3907
+    tx_pool_test.go:3722: [12:12:06.110] mining block. block 304. total 0: pending 0(added 0), local 0(added 0), queued 3920
+    tx_pool_test.go:3722: [12:12:07.110] mining block. block 305. total 0: pending 0(added 0), local 0(added 0), queued 3936
+    tx_pool_test.go:3722: [12:12:08.111] mining block. block 306. total 0: pending 0(added 0), local 0(added 0), queued 3948
+    tx_pool_test.go:3722: [12:12:09.111] mining block. block 307. total 0: pending 0(added 0), local 0(added 0), queued 3962
+    tx_pool_test.go:3722: [12:12:10.111] mining block. block 308. total 0: pending 0(added 0), local 0(added 0), queued 3974
+    tx_pool_test.go:3722: [12:12:11.111] mining block. block 309. total 0: pending 0(added 0), local 0(added 0), queued 3987
+    tx_pool_test.go:3722: [12:12:12.111] mining block. block 310. total 0: pending 0(added 0), local 0(added 0), queued 3998
+    tx_pool_test.go:3722: [12:12:13.112] mining block. block 311. total 0: pending 0(added 0), local 0(added 0), queued 4011
+    tx_pool_test.go:3722: [12:12:14.112] mining block. block 312. total 0: pending 0(added 0), local 0(added 0), queued 4024
+    tx_pool_test.go:3722: [12:12:15.111] mining block. block 313. total 0: pending 0(added 0), local 0(added 0), queued 4035
+    tx_pool_test.go:3722: [12:12:16.111] mining block. block 314. total 0: pending 0(added 0), local 0(added 0), queued 4047
+    tx_pool_test.go:3722: [12:12:17.112] mining block. block 315. total 0: pending 0(added 0), local 0(added 0), queued 4059
+    tx_pool_test.go:3722: [12:12:18.111] mining block. block 316. total 0: pending 0(added 0), local 0(added 0), queued 4074
+    tx_pool_test.go:3722: [12:12:19.111] mining block. block 317. total 0: pending 0(added 0), local 0(added 0), queued 4087
+    tx_pool_test.go:3722: [12:12:20.111] mining block. block 318. total 0: pending 0(added 0), local 0(added 0), queued 4099
+    tx_pool_test.go:3722: [12:12:21.111] mining block. block 319. total 0: pending 0(added 0), local 0(added 0), queued 4114
+    tx_pool_test.go:3722: [12:12:22.112] mining block. block 320. total 0: pending 0(added 0), local 0(added 0), queued 4126
+    tx_pool_test.go:3722: [12:12:23.111] mining block. block 321. total 0: pending 0(added 0), local 0(added 0), queued 4140
+    tx_pool_test.go:3722: [12:12:24.111] mining block. block 322. total 0: pending 0(added 0), local 0(added 0), queued 4153
+    tx_pool_test.go:3722: [12:12:25.111] mining block. block 323. total 0: pending 0(added 0), local 0(added 0), queued 4166
+    tx_pool_test.go:3722: [12:12:26.111] mining block. block 324. total 0: pending 0(added 0), local 0(added 0), queued 4179
+    tx_pool_test.go:3722: [12:12:27.111] mining block. block 325. total 0: pending 0(added 0), local 0(added 0), queued 4192
+    tx_pool_test.go:3722: [12:12:28.112] mining block. block 326. total 0: pending 0(added 0), local 0(added 0), queued 4205
+    tx_pool_test.go:3722: [12:12:29.111] mining block. block 327. total 0: pending 0(added 0), local 0(added 0), queued 4219
+    tx_pool_test.go:3722: [12:12:30.111] mining block. block 328. total 0: pending 0(added 0), local 0(added 0), queued 4229
+    tx_pool_test.go:3722: [12:12:31.111] mining block. block 329. total 0: pending 0(added 0), local 0(added 0), queued 4242
+    tx_pool_test.go:3722: [12:12:32.111] mining block. block 330. total 0: pending 0(added 0), local 0(added 0), queued 4254
+    tx_pool_test.go:3722: [12:12:33.111] mining block. block 331. total 0: pending 0(added 0), local 0(added 0), queued 4266
+    tx_pool_test.go:3722: [12:12:34.110] mining block. block 332. total 0: pending 0(added 0), local 0(added 0), queued 4277
+    tx_pool_test.go:3722: [12:12:35.111] mining block. block 333. total 0: pending 0(added 0), local 0(added 0), queued 4291
+    tx_pool_test.go:3722: [12:12:36.112] mining block. block 334. total 0: pending 0(added 0), local 0(added 0), queued 4303
+    tx_pool_test.go:3722: [12:12:37.111] mining block. block 335. total 0: pending 0(added 0), local 0(added 0), queued 4315
+    tx_pool_test.go:3722: [12:12:38.111] mining block. block 336. total 0: pending 0(added 0), local 0(added 0), queued 4328
+    tx_pool_test.go:3722: [12:12:39.112] mining block. block 337. total 0: pending 0(added 0), local 0(added 0), queued 4339
+    tx_pool_test.go:3722: [12:12:40.111] mining block. block 338. total 0: pending 0(added 0), local 0(added 0), queued 4353
+    tx_pool_test.go:3722: [12:12:41.111] mining block. block 339. total 0: pending 0(added 0), local 0(added 0), queued 4366
+    tx_pool_test.go:3722: [12:12:42.111] mining block. block 340. total 0: pending 0(added 0), local 0(added 0), queued 4378
+    tx_pool_test.go:3722: [12:12:43.111] mining block. block 341. total 0: pending 0(added 0), local 0(added 0), queued 4392
+    tx_pool_test.go:3722: [12:12:44.112] mining block. block 342. total 0: pending 0(added 0), local 0(added 0), queued 4406
+    tx_pool_test.go:3722: [12:12:45.110] mining block. block 343. total 0: pending 0(added 0), local 0(added 0), queued 4417
+    tx_pool_test.go:3722: [12:12:46.111] mining block. block 344. total 0: pending 0(added 0), local 0(added 0), queued 4429
+    tx_pool_test.go:3722: [12:12:47.111] mining block. block 345. total 0: pending 0(added 0), local 0(added 0), queued 4440
+    tx_pool_test.go:3722: [12:12:48.111] mining block. block 346. total 0: pending 0(added 0), local 0(added 0), queued 4453
+    tx_pool_test.go:3722: [12:12:49.111] mining block. block 347. total 0: pending 0(added 0), local 0(added 0), queued 4468
+    tx_pool_test.go:3722: [12:12:50.111] mining block. block 348. total 0: pending 0(added 0), local 0(added 0), queued 4480
+    tx_pool_test.go:3722: [12:12:51.110] mining block. block 349. total 0: pending 0(added 0), local 0(added 0), queued 4492
+    tx_pool_test.go:3722: [12:12:52.110] mining block. block 350. total 0: pending 0(added 0), local 0(added 0), queued 4504
+    tx_pool_test.go:3722: [12:12:53.110] mining block. block 351. total 0: pending 0(added 0), local 0(added 0), queued 4516
+    tx_pool_test.go:3722: [12:12:54.111] mining block. block 352. total 0: pending 0(added 0), local 0(added 0), queued 4528
+    tx_pool_test.go:3722: [12:12:55.111] mining block. block 353. total 0: pending 0(added 0), local 0(added 0), queued 4542
+    tx_pool_test.go:3722: [12:12:56.111] mining block. block 354. total 0: pending 0(added 0), local 0(added 0), queued 4555
+    tx_pool_test.go:3722: [12:12:57.110] mining block. block 355. total 0: pending 0(added 0), local 0(added 0), queued 4570
+    tx_pool_test.go:3722: [12:12:58.111] mining block. block 356. total 0: pending 0(added 0), local 0(added 0), queued 4582
+    tx_pool_test.go:3722: [12:12:59.111] mining block. block 357. total 0: pending 0(added 0), local 0(added 0), queued 4595
+    tx_pool_test.go:3722: [12:13:00.111] mining block. block 358. total 0: pending 0(added 0), local 0(added 0), queued 4609
+    tx_pool_test.go:3722: [12:13:01.111] mining block. block 359. total 0: pending 0(added 0), local 0(added 0), queued 4621
+    tx_pool_test.go:3722: [12:13:02.111] mining block. block 360. total 0: pending 0(added 0), local 0(added 0), queued 4634
+    tx_pool_test.go:3722: [12:13:03.111] mining block. block 361. total 0: pending 0(added 0), local 0(added 0), queued 4646
+    tx_pool_test.go:3722: [12:13:04.111] mining block. block 362. total 0: pending 0(added 0), local 0(added 0), queued 4659
+    tx_pool_test.go:3722: [12:13:05.111] mining block. block 363. total 0: pending 0(added 0), local 0(added 0), queued 4671
+    tx_pool_test.go:3722: [12:13:06.110] mining block. block 364. total 0: pending 0(added 0), local 0(added 0), queued 4683
+    tx_pool_test.go:3722: [12:13:07.111] mining block. block 365. total 0: pending 0(added 0), local 0(added 0), queued 4699
+    tx_pool_test.go:3722: [12:13:08.110] mining block. block 366. total 0: pending 0(added 0), local 0(added 0), queued 4713
+    tx_pool_test.go:3722: [12:13:09.112] mining block. block 367. total 0: pending 0(added 0), local 0(added 0), queued 4726
+    tx_pool_test.go:3722: [12:13:10.110] mining block. block 368. total 0: pending 0(added 0), local 0(added 0), queued 4738
+    tx_pool_test.go:3722: [12:13:11.110] mining block. block 369. total 0: pending 0(added 0), local 0(added 0), queued 4751
+    tx_pool_test.go:3722: [12:13:12.110] mining block. block 370. total 0: pending 0(added 0), local 0(added 0), queued 4765
+    tx_pool_test.go:3722: [12:13:13.110] mining block. block 371. total 0: pending 0(added 0), local 0(added 0), queued 4777
+    tx_pool_test.go:3722: [12:13:14.112] mining block. block 372. total 0: pending 0(added 0), local 0(added 0), queued 4790
+    tx_pool_test.go:3722: [12:13:15.111] mining block. block 373. total 0: pending 0(added 0), local 0(added 0), queued 4805
+    tx_pool_test.go:3722: [12:13:16.111] mining block. block 374. total 0: pending 0(added 0), local 0(added 0), queued 4817
+    tx_pool_test.go:3722: [12:13:17.115] mining block. block 375. total 0: pending 0(added 0), local 0(added 0), queued 4830
+    tx_pool_test.go:3722: [12:13:18.112] mining block. block 376. total 0: pending 0(added 0), local 0(added 0), queued 4841
+    tx_pool_test.go:3722: [12:13:19.111] mining block. block 377. total 0: pending 0(added 0), local 0(added 0), queued 4852
+    tx_pool_test.go:3722: [12:13:20.110] mining block. block 378. total 0: pending 0(added 0), local 0(added 0), queued 4865
+    tx_pool_test.go:3722: [12:13:21.112] mining block. block 379. total 0: pending 0(added 0), local 0(added 0), queued 4877
+    tx_pool_test.go:3722: [12:13:22.110] mining block. block 380. total 0: pending 0(added 0), local 0(added 0), queued 4890
+    tx_pool_test.go:3722: [12:13:23.111] mining block. block 381. total 0: pending 0(added 0), local 0(added 0), queued 4903
+    tx_pool_test.go:3722: [12:13:24.110] mining block. block 382. total 0: pending 0(added 0), local 0(added 0), queued 4917
+    tx_pool_test.go:3722: [12:13:25.112] mining block. block 383. total 0: pending 0(added 0), local 0(added 0), queued 4930
+    tx_pool_test.go:3722: [12:13:26.110] mining block. block 384. total 0: pending 0(added 0), local 0(added 0), queued 4941
+    tx_pool_test.go:3722: [12:13:27.110] mining block. block 385. total 0: pending 0(added 0), local 0(added 0), queued 4954
+    tx_pool_test.go:3722: [12:13:28.112] mining block. block 386. total 0: pending 0(added 0), local 0(added 0), queued 4966
+    tx_pool_test.go:3722: [12:13:29.110] mining block. block 387. total 0: pending 0(added 0), local 0(added 0), queued 4981
+    tx_pool_test.go:3722: [12:13:30.112] mining block. block 388. total 0: pending 0(added 0), local 0(added 0), queued 4994
+    tx_pool_test.go:3722: [12:13:31.112] mining block. block 389. total 0: pending 0(added 0), local 0(added 0), queued 5005
+    tx_pool_test.go:3722: [12:13:32.112] mining block. block 390. total 0: pending 0(added 0), local 0(added 0), queued 5017
+    tx_pool_test.go:3722: [12:13:33.110] mining block. block 391. total 0: pending 0(added 0), local 0(added 0), queued 5031
+    tx_pool_test.go:3722: [12:13:34.111] mining block. block 392. total 0: pending 0(added 0), local 0(added 0), queued 5043
+    tx_pool_test.go:3722: [12:13:35.110] mining block. block 393. total 0: pending 0(added 0), local 0(added 0), queued 5056
+    tx_pool_test.go:3722: [12:13:36.112] mining block. block 394. total 0: pending 0(added 0), local 0(added 0), queued 5071
+    tx_pool_test.go:3722: [12:13:37.110] mining block. block 395. total 0: pending 0(added 0), local 0(added 0), queued 5085
+    tx_pool_test.go:3722: [12:13:38.110] mining block. block 396. total 0: pending 0(added 0), local 0(added 0), queued 5100
+    tx_pool_test.go:3722: [12:13:39.112] mining block. block 397. total 0: pending 0(added 0), local 0(added 0), queued 5116
+    tx_pool_test.go:3722: [12:13:40.112] mining block. block 398. total 0: pending 0(added 0), local 0(added 0), queued 5129
+    tx_pool_test.go:3722: [12:13:41.110] mining block. block 399. total 0: pending 0(added 0), local 0(added 0), queued 5142
+    tx_pool_test.go:3722: [12:13:42.111] mining block. block 400. total 0: pending 0(added 0), local 0(added 0), queued 5153
+    tx_pool_test.go:3722: [12:13:43.111] mining block. block 401. total 0: pending 0(added 0), local 0(added 0), queued 5167
+    tx_pool_test.go:3722: [12:13:44.112] mining block. block 402. total 0: pending 0(added 0), local 0(added 0), queued 5177
+    tx_pool_test.go:3722: [12:13:45.111] mining block. block 403. total 0: pending 0(added 0), local 0(added 0), queued 5189
+    tx_pool_test.go:3722: [12:13:46.110] mining block. block 404. total 0: pending 0(added 0), local 0(added 0), queued 5202
+    tx_pool_test.go:3722: [12:13:47.111] mining block. block 405. total 0: pending 0(added 0), local 0(added 0), queued 5213
+    tx_pool_test.go:3722: [12:13:48.111] mining block. block 406. total 0: pending 0(added 0), local 0(added 0), queued 5226
+    tx_pool_test.go:3722: [12:13:49.111] mining block. block 407. total 0: pending 0(added 0), local 0(added 0), queued 5238
+    tx_pool_test.go:3722: [12:13:50.110] mining block. block 408. total 0: pending 0(added 0), local 0(added 0), queued 5248
+    tx_pool_test.go:3722: [12:13:51.110] mining block. block 409. total 0: pending 0(added 0), local 0(added 0), queued 5260
+    tx_pool_test.go:3722: [12:13:52.110] mining block. block 410. total 0: pending 0(added 0), local 0(added 0), queued 5273
+    tx_pool_test.go:3722: [12:13:53.111] mining block. block 411. total 0: pending 0(added 0), local 0(added 0), queued 5286
+    tx_pool_test.go:3722: [12:13:54.112] mining block. block 412. total 0: pending 0(added 0), local 0(added 0), queued 5299
+    tx_pool_test.go:3722: [12:13:55.112] mining block. block 413. total 0: pending 0(added 0), local 0(added 0), queued 5313
+    tx_pool_test.go:3722: [12:13:56.112] mining block. block 414. total 0: pending 0(added 0), local 0(added 0), queued 5324
+    tx_pool_test.go:3722: [12:13:57.112] mining block. block 415. total 0: pending 0(added 0), local 0(added 0), queued 5338
+    tx_pool_test.go:3722: [12:13:58.110] mining block. block 416. total 0: pending 0(added 0), local 0(added 0), queued 5351
+    tx_pool_test.go:3722: [12:13:59.112] mining block. block 417. total 0: pending 0(added 0), local 0(added 0), queued 5365
+    tx_pool_test.go:3722: [12:14:00.110] mining block. block 418. total 0: pending 0(added 0), local 0(added 0), queued 5380
+    tx_pool_test.go:3722: [12:14:01.114] mining block. block 419. total 0: pending 0(added 0), local 0(added 0), queued 5393
+    tx_pool_test.go:3722: [12:14:02.111] mining block. block 420. total 0: pending 0(added 0), local 0(added 0), queued 5404
+    tx_pool_test.go:3722: [12:14:03.112] mining block. block 421. total 0: pending 0(added 0), local 0(added 0), queued 5418
+    tx_pool_test.go:3722: [12:14:04.112] mining block. block 422. total 0: pending 0(added 0), local 0(added 0), queued 5430
+    tx_pool_test.go:3722: [12:14:05.112] mining block. block 423. total 0: pending 0(added 0), local 0(added 0), queued 5443
+    tx_pool_test.go:3722: [12:14:06.112] mining block. block 424. total 0: pending 0(added 0), local 0(added 0), queued 5456
+    tx_pool_test.go:3722: [12:14:07.111] mining block. block 425. total 0: pending 0(added 0), local 0(added 0), queued 5468
+    tx_pool_test.go:3722: [12:14:08.112] mining block. block 426. total 0: pending 0(added 0), local 0(added 0), queued 5479
+    tx_pool_test.go:3722: [12:14:09.112] mining block. block 427. total 0: pending 0(added 0), local 0(added 0), queued 5491
+    tx_pool_test.go:3722: [12:14:10.112] mining block. block 428. total 0: pending 0(added 0), local 0(added 0), queued 5506
+    tx_pool_test.go:3722: [12:14:11.110] mining block. block 429. total 0: pending 0(added 0), local 0(added 0), queued 5521
+    tx_pool_test.go:3722: [12:14:12.112] mining block. block 430. total 0: pending 0(added 0), local 0(added 0), queued 5532
+    tx_pool_test.go:3722: [12:14:13.110] mining block. block 431. total 0: pending 0(added 0), local 0(added 0), queued 5545
+    tx_pool_test.go:3722: [12:14:14.112] mining block. block 432. total 0: pending 0(added 0), local 0(added 0), queued 5560
+    tx_pool_test.go:3722: [12:14:15.110] mining block. block 433. total 0: pending 0(added 0), local 0(added 0), queued 5575
+    tx_pool_test.go:3722: [12:14:16.112] mining block. block 434. total 0: pending 0(added 0), local 0(added 0), queued 5588
+    tx_pool_test.go:3722: [12:14:17.111] mining block. block 435. total 0: pending 0(added 0), local 0(added 0), queued 5601
+    tx_pool_test.go:3722: [12:14:18.112] mining block. block 436. total 0: pending 0(added 0), local 0(added 0), queued 5611
+    tx_pool_test.go:3722: [12:14:19.110] mining block. block 437. total 0: pending 0(added 0), local 0(added 0), queued 5625
+    tx_pool_test.go:3722: [12:14:20.110] mining block. block 438. total 0: pending 0(added 0), local 0(added 0), queued 5637
+    tx_pool_test.go:3722: [12:14:21.112] mining block. block 439. total 0: pending 0(added 0), local 0(added 0), queued 5650
+    tx_pool_test.go:3722: [12:14:22.112] mining block. block 440. total 0: pending 0(added 0), local 0(added 0), queued 5663
+    tx_pool_test.go:3722: [12:14:23.111] mining block. block 441. total 0: pending 0(added 0), local 0(added 0), queued 5675
+    tx_pool_test.go:3722: [12:14:24.110] mining block. block 442. total 0: pending 0(added 0), local 0(added 0), queued 5687
+    tx_pool_test.go:3722: [12:14:25.112] mining block. block 443. total 0: pending 0(added 0), local 0(added 0), queued 5698
+    tx_pool_test.go:3722: [12:14:26.112] mining block. block 444. total 0: pending 0(added 0), local 0(added 0), queued 5710
+    tx_pool_test.go:3722: [12:14:27.111] mining block. block 445. total 0: pending 0(added 0), local 0(added 0), queued 5722
+    tx_pool_test.go:3722: [12:14:28.112] mining block. block 446. total 0: pending 0(added 0), local 0(added 0), queued 5734
+    tx_pool_test.go:3722: [12:14:29.110] mining block. block 447. total 0: pending 0(added 0), local 0(added 0), queued 5747
+    tx_pool_test.go:3722: [12:14:30.111] mining block. block 448. total 0: pending 0(added 0), local 0(added 0), queued 5759
+    tx_pool_test.go:3722: [12:14:31.110] mining block. block 449. total 0: pending 0(added 0), local 0(added 0), queued 5774
+    tx_pool_test.go:3722: [12:14:32.112] mining block. block 450. total 0: pending 0(added 0), local 0(added 0), queued 5784
+    tx_pool_test.go:3722: [12:14:33.110] mining block. block 451. total 0: pending 0(added 0), local 0(added 0), queued 5797
+    tx_pool_test.go:3722: [12:14:34.112] mining block. block 452. total 0: pending 0(added 0), local 0(added 0), queued 5810
+    tx_pool_test.go:3722: [12:14:35.111] mining block. block 453. total 0: pending 0(added 0), local 0(added 0), queued 5822
+    tx_pool_test.go:3722: [12:14:36.110] mining block. block 454. total 0: pending 0(added 0), local 0(added 0), queued 5835
+    tx_pool_test.go:3722: [12:14:37.111] mining block. block 455. total 0: pending 0(added 0), local 0(added 0), queued 5848
+    tx_pool_test.go:3722: [12:14:38.111] mining block. block 456. total 0: pending 0(added 0), local 0(added 0), queued 5861
+    tx_pool_test.go:3722: [12:14:39.112] mining block. block 457. total 0: pending 0(added 0), local 0(added 0), queued 5873
+    tx_pool_test.go:3722: [12:14:40.110] mining block. block 458. total 0: pending 0(added 0), local 0(added 0), queued 5889
+    tx_pool_test.go:3722: [12:14:41.112] mining block. block 459. total 0: pending 0(added 0), local 0(added 0), queued 5900
+    tx_pool_test.go:3722: [12:14:42.110] mining block. block 460. total 0: pending 0(added 0), local 0(added 0), queued 5915
+    tx_pool_test.go:3722: [12:14:43.111] mining block. block 461. total 0: pending 0(added 0), local 0(added 0), queued 5927
+    tx_pool_test.go:3722: [12:14:44.112] mining block. block 462. total 0: pending 0(added 0), local 0(added 0), queued 5938
+    tx_pool_test.go:3722: [12:14:45.111] mining block. block 463. total 0: pending 0(added 0), local 0(added 0), queued 5951
+    tx_pool_test.go:3722: [12:14:46.112] mining block. block 464. total 0: pending 0(added 0), local 0(added 0), queued 5962
+    tx_pool_test.go:3722: [12:14:47.111] mining block. block 465. total 0: pending 0(added 0), local 0(added 0), queued 5976
+    tx_pool_test.go:3722: [12:14:48.112] mining block. block 466. total 0: pending 0(added 0), local 0(added 0), queued 5988
+    tx_pool_test.go:3722: [12:14:49.111] mining block. block 467. total 0: pending 0(added 0), local 0(added 0), queued 6001
+    tx_pool_test.go:3722: [12:14:50.112] mining block. block 468. total 0: pending 0(added 0), local 0(added 0), queued 6013
+    tx_pool_test.go:3722: [12:14:51.112] mining block. block 469. total 0: pending 0(added 0), local 0(added 0), queued 6026
+    tx_pool_test.go:3722: [12:14:52.111] mining block. block 470. total 0: pending 0(added 0), local 0(added 0), queued 6041
+    tx_pool_test.go:3722: [12:14:53.112] mining block. block 471. total 0: pending 0(added 0), local 0(added 0), queued 6053
+    tx_pool_test.go:3722: [12:14:54.110] mining block. block 472. total 0: pending 0(added 0), local 0(added 0), queued 6067
+    tx_pool_test.go:3722: [12:14:55.112] mining block. block 473. total 0: pending 0(added 0), local 0(added 0), queued 6079
+    tx_pool_test.go:3722: [12:14:56.110] mining block. block 474. total 0: pending 0(added 0), local 0(added 0), queued 6089
+    tx_pool_test.go:3722: [12:14:57.110] mining block. block 475. total 0: pending 0(added 0), local 0(added 0), queued 6104
+    tx_pool_test.go:3722: [12:14:58.110] mining block. block 476. total 0: pending 0(added 0), local 0(added 0), queued 6118
+    tx_pool_test.go:3722: [12:14:59.110] mining block. block 477. total 0: pending 0(added 0), local 0(added 0), queued 6133
+    tx_pool_test.go:4148: AddRemoteSync error: transaction underpriced
+    tx_pool_test.go:4127: [12:14:59.831] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.836] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.883] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.888] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.935] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.939] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.987] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:14:59.990] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.039] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.041] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.091] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.092] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:00.112] mining block. block 478. total 0: pending 0(added 0), local 0(added 0), queued 6149
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.143] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.143] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.195] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.196] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.249] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.250] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.300] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.301] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.351] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.352] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.405] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.405] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.458] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.459] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.509] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.510] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.561] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.561] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.613] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.614] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.666] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.666] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.717] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.717] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.770] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.770] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.822] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.822] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.874] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.874] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.925] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.927] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.977] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:00.978] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.030] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.030] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.081] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.081] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:01.111] mining block. block 479. total 0: pending 0(added 0), local 0(added 0), queued 6162
+    tx_pool_test.go:4127: [12:15:01.134] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.134] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.186] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.186] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.236] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.237] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.288] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.288] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.339] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.340] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.393] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.394] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.444] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.445] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.495] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.496] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.547] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.548] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.598] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.599] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.649] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.649] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.701] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.701] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.753] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.754] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.804] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.805] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.857] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.858] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.909] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.909] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.961] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:01.963] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.014] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.015] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.066] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.066] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:02.112] mining block. block 480. total 0: pending 0(added 0), local 0(added 0), queued 6174
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.117] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.118] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.170] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.170] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.221] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.222] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.274] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.275] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.327] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.327] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.378] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.379] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.430] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.431] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.482] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.482] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.534] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.534] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.585] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.586] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.638] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.638] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.689] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.689] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.740] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.740] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.791] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.792] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.843] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.844] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.895] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.895] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.946] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.947] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.998] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:02.998] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.050] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.050] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.102] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.103] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:03.111] mining block. block 481. total 0: pending 0(added 0), local 0(added 0), queued 6188
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.154] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.155] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.207] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.207] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.259] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.260] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.310] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.311] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.362] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.362] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.414] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.414] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.466] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.466] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.518] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.518] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.570] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.570] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.622] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.622] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.675] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.676] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.725] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.726] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.777] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.778] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.829] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.829] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.883] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.884] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.934] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.934] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.984] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:03.985] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.036] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.036] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.087] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.087] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:04.112] mining block. block 482. total 0: pending 0(added 0), local 0(added 0), queued 6202
+    tx_pool_test.go:4127: [12:15:04.139] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.139] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.192] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.194] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.243] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.244] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.297] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.297] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.349] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.350] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.402] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.402] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.455] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.456] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.506] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.507] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.560] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.561] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.611] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.612] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.663] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.664] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.716] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.716] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.768] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.768] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.820] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.820] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.873] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.874] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.926] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.927] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.977] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:04.978] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.030] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.031] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.083] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.084] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:05.112] mining block. block 483. total 0: pending 0(added 0), local 0(added 0), queued 6215
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.134] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.134] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.189] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.189] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.240] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.240] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.291] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.292] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.344] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.345] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.396] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.397] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.448] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.449] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.499] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.500] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.551] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.552] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.604] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.605] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.656] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.657] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.708] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.709] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.761] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.761] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.814] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.814] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.865] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.866] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.917] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.919] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.970] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:05.970] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.022] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.022] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.073] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.073] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:06.111] mining block. block 484. total 0: pending 0(added 0), local 0(added 0), queued 6228
+    tx_pool_test.go:4127: [12:15:06.125] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.125] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.176] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.178] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.231] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.231] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.282] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.282] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.333] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.333] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.384] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.385] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.436] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.436] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.488] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.489] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.540] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.540] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.592] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.592] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.642] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.643] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.694] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.698] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.745] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.750] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.797] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.801] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.849] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.852] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.901] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.903] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.953] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:06.953] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.005] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.005] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.056] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.056] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.108] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.108] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:07.110] mining block. block 485. total 0: pending 0(added 0), local 0(added 0), queued 6241
+    tx_pool_test.go:4127: [12:15:07.161] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.161] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.213] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.214] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.266] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.266] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.317] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.317] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.370] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.371] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.421] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.422] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.474] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.474] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.526] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.527] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.580] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.581] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.633] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.634] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.685] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.685] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.736] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.737] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.788] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.788] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.840] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.840] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.891] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.893] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.945] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.946] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:07.999] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.003] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.052] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.054] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.105] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.105] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:08.110] mining block. block 486. total 0: pending 0(added 0), local 0(added 0), queued 6253
+    tx_pool_test.go:4127: [12:15:08.156] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.156] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.207] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.207] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.260] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.260] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.311] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.312] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.363] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.364] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.415] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.416] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.466] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.466] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.518] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.518] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.570] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.570] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.621] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.621] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.673] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.673] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.725] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.725] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.776] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.777] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.828] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.828] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.879] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.879] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.931] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.931] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.983] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:08.984] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.035] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.036] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.087] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.088] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:09.112] mining block. block 487. total 0: pending 0(added 0), local 0(added 0), queued 6266
+    tx_pool_test.go:4127: [12:15:09.140] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.140] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.192] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.192] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.244] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.244] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.295] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.296] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.348] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.349] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.404] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.404] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.454] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.455] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.507] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.508] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.559] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.560] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.612] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.612] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.663] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.664] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.716] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.716] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.767] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.767] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.818] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.818] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.871] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.871] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.923] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.923] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.975] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:09.975] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.027] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.027] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.078] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.079] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:10.110] mining block. block 488. total 0: pending 0(added 0), local 0(added 0), queued 6277
+    tx_pool_test.go:4127: [12:15:10.130] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.131] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.182] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.182] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.233] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.233] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.285] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.285] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.338] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.339] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.391] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.392] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.445] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.447] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.501] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.501] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.552] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.553] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.605] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.606] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.658] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.658] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.711] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.712] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.764] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.764] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.816] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.816] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.868] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.869] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.921] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.921] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.974] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:10.974] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.026] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.026] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.078] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.080] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:11.111] mining block. block 489. total 0: pending 0(added 0), local 0(added 0), queued 6290
+    tx_pool_test.go:4127: [12:15:11.130] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.131] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.183] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.183] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.235] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.235] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.288] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.288] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.339] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.340] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.392] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.393] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.443] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.443] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.494] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.494] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.545] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.547] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.598] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.599] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.649] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.650] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.700] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.701] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.752] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.753] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.804] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.804] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.855] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.856] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.908] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.909] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.962] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:11.962] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.014] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.014] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.066] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.066] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:12.110] mining block. block 490. total 0: pending 0(added 0), local 0(added 0), queued 6302
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.116] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.117] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.168] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.168] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.220] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.221] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.272] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.272] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.324] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.325] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.376] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.376] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.428] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.428] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.481] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.482] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.532] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.533] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.584] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.584] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.635] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.636] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.686] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.687] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.738] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.740] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.789] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.791] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.840] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.841] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.892] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.893] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.944] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.944] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.995] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:12.997] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.046] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.047] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.098] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.100] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:13.111] mining block. block 491. total 0: pending 0(added 0), local 0(added 0), queued 6317
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.150] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.151] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.202] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.203] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.254] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.254] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.305] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.305] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.359] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.359] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.411] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.412] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.462] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.462] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.514] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.514] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.566] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.566] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.618] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.618] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.670] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.670] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.723] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.724] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.774] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.775] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.827] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.827] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.877] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.878] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.930] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.931] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.981] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:13.982] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.033] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.034] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.086] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.086] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:14.112] mining block. block 492. total 0: pending 0(added 0), local 0(added 0), queued 6328
+    tx_pool_test.go:4127: [12:15:14.137] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.137] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.189] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.189] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.242] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.242] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.293] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.294] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.345] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.346] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.396] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.396] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.447] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.448] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.499] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.499] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.550] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.550] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.601] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.602] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.654] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.654] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.706] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.706] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.758] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.758] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.809] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.810] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.861] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.862] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.915] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.915] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.966] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:14.967] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.018] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.019] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.071] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.071] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:15.112] mining block. block 493. total 0: pending 0(added 0), local 0(added 0), queued 6342
+    tx_pool_test.go:4127: [12:15:15.123] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.124] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.175] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.175] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.228] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.228] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.280] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.280] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.332] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.332] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.384] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.385] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.436] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.437] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.489] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.490] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.541] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.543] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.593] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.594] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.646] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.646] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.699] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.700] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.750] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.751] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.802] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.803] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.853] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.854] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.905] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.905] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.957] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:15.958] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.009] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.010] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.062] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.063] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:16.112] mining block. block 494. total 0: pending 0(added 0), local 0(added 0), queued 6358
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.114] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.114] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.165] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.165] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.217] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.217] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.269] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.269] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.320] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.320] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.372] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.373] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.425] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.426] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.478] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.479] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.532] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.532] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.583] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.584] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.636] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.637] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.687] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.688] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.741] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.741] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.792] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.793] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.844] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.845] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.897] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.897] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.949] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:16.950] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.001] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.002] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.054] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.054] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.106] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.107] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:17.110] mining block. block 495. total 0: pending 0(added 0), local 0(added 0), queued 6371
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.158] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.159] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.210] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.210] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.262] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.263] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.326] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.327] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.378] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.378] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.430] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.430] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.483] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.483] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.534] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.534] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.585] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.585] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.636] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.637] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.689] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.689] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.741] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.741] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.793] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.794] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.846] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.847] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.897] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.898] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.951] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:17.951] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.002] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.002] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.054] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.055] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.107] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.107] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:18.110] mining block. block 496. total 0: pending 0(added 0), local 0(added 0), queued 6384
+    tx_pool_test.go:4127: [12:15:18.159] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.160] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.210] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.210] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.262] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.263] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.313] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.314] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.365] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.366] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.417] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.417] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.469] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.470] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.522] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.522] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.574] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.574] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.626] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.626] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.677] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.677] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.729] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.729] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.780] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.780] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.833] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.833] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.883] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.884] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.935] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.935] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.987] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:18.987] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.039] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.039] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.091] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.091] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:19.112] mining block. block 497. total 0: pending 0(added 0), local 0(added 0), queued 6397
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.143] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.143] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.195] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.195] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.248] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.248] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.299] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.300] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.351] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.351] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.402] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.403] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.454] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.454] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.506] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.506] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.558] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.558] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.609] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.610] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.661] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.662] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.712] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.712] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.763] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.764] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.816] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.816] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.867] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.867] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.918] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.918] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.969] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:19.969] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.021] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.022] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.074] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.074] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:20.111] mining block. block 498. total 0: pending 0(added 0), local 0(added 0), queued 6410
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.125] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.125] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.176] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.176] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.228] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.229] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.279] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.280] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.329] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.331] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.381] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.382] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.432] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.432] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.485] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.485] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.536] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.536] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.588] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.588] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.639] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.639] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.692] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.692] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.744] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.746] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.797] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.798] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.848] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.849] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.899] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.899] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.951] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:20.951] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.003] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.003] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.054] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.055] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.106] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.106] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:21.111] mining block. block 499. total 0: pending 0(added 0), local 0(added 0), queued 6422
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.159] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.159] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.209] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.210] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.261] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.262] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.314] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.316] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.366] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.367] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.418] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.418] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.470] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.471] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.522] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.523] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.574] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.575] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.625] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.626] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.676] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.676] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.731] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.731] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.784] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.785] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.836] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.837] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.886] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.889] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.939] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.940] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.990] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:21.991] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.041] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.042] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.093] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.093] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:22.112] mining block. block 500. total 0: pending 0(added 0), local 0(added 0), queued 6435
+    tx_pool_test.go:4127: [12:15:22.145] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.145] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.196] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.197] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.249] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.250] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.302] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.302] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.353] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.353] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.405] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.405] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.457] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.457] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.508] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.509] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.559] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.560] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.611] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.612] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.662] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.663] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.714] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.715] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.766] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.766] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.817] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.817] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.868] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.868] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.920] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.920] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.972] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:22.973] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.023] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.025] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.075] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.075] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:23.111] mining block. block 501. total 0: pending 0(added 0), local 0(added 0), queued 6447
+    tx_pool_test.go:4127: [12:15:23.126] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.127] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.178] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.178] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.231] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.231] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.283] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.284] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.336] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.336] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.387] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.387] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.438] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.449] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.491] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.500] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.543] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.551] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.594] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.603] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.645] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.655] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.697] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.707] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.749] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.760] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.802] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.812] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.854] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.866] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.904] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.919] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.956] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:23.971] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.009] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.022] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.060] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.074] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:24.112] mining block. block 502. total 0: pending 0(added 0), local 0(added 0), queued 6459
+    tx_pool_test.go:4127: [12:15:24.112] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.127] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.164] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.178] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.217] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.231] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.269] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.283] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.322] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.335] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.376] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.387] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.428] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.438] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.482] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.491] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.533] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.543] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.586] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.595] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.637] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.648] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.689] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.700] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.742] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.751] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.794] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.803] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.848] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.856] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.899] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.908] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.953] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:24.959] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.004] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.011] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.057] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.063] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.108] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:25.110] mining block. block 503. total 0: pending 0(added 0), local 0(added 0), queued 6472
+    tx_pool_test.go:4127: [12:15:25.115] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.161] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.166] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.212] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.217] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.263] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.269] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.314] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.321] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.369] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.371] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.422] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.422] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.472] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.473] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.525] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.526] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.579] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.580] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.633] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.634] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.684] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.685] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.736] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.736] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.788] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.791] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.841] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.843] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.894] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.894] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.945] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.945] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.996] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:25.996] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.049] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.050] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.100] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.101] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:26.110] mining block. block 504. total 0: pending 0(added 0), local 0(added 0), queued 6485
+    tx_pool_test.go:4127: [12:15:26.152] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.152] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.204] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.204] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.258] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.259] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.309] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.310] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.363] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.364] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.414] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.415] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.467] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.467] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.519] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.519] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.570] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.571] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.624] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.624] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.677] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.678] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.729] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.729] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.780] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.780] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.832] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.833] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.883] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.884] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.935] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.936] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.986] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:26.987] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.038] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.038] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.090] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.091] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:27.112] mining block. block 505. total 0: pending 0(added 0), local 0(added 0), queued 6497
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.142] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.143] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.193] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.194] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.246] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.246] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.303] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.303] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.355] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.357] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.408] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.408] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.460] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.460] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.511] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.512] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.563] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.563] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.616] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.616] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.667] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.668] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.721] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.722] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.773] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.773] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.824] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.825] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.875] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.876] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.926] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.927] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.977] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:27.977] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.028] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.028] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.078] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.079] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:28.112] mining block. block 506. total 0: pending 0(added 0), local 0(added 0), queued 6509
+    tx_pool_test.go:4127: [12:15:28.131] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.132] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.182] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.183] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.234] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.235] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.286] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.286] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.338] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.338] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.389] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.389] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.441] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.441] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.493] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.493] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.544] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.544] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.596] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.596] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.648] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.648] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.700] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.700] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.752] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.752] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.805] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.805] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.857] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.857] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.908] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.908] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.960] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:28.961] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.014] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.014] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.064] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.065] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:29.112] mining block. block 507. total 0: pending 0(added 0), local 0(added 0), queued 6521
+    tx_pool_test.go:4127: [12:15:29.115] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.115] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.167] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.167] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.219] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.219] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.271] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.271] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.324] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.326] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.375] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.377] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.432] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.433] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.483] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.484] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.534] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.535] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.586] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.586] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.638] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.638] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.689] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.691] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.740] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.743] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.791] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.794] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.842] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.846] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.893] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.897] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.947] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.948] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.999] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:29.999] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.050] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.051] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.102] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.103] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:30.110] mining block. block 508. total 0: pending 0(added 0), local 0(added 0), queued 6535
+    tx_pool_test.go:4127: [12:15:30.154] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.156] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.206] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.207] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.259] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.261] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.310] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.312] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.362] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.363] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.417] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.418] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.470] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.471] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.523] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.523] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.576] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.576] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.629] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.629] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.681] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.682] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.736] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.737] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.788] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.788] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.841] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.843] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.893] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.894] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.944] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.945] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.995] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:30.995] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.046] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.047] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.099] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.099] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:31.111] mining block. block 509. total 0: pending 0(added 0), local 0(added 0), queued 6549
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.151] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.151] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.202] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.203] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.255] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.256] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.306] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.307] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.359] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.359] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.411] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.411] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.464] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.464] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.516] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.516] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.566] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.567] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.618] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.619] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.670] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.672] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.727] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.728] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.780] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.782] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.833] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.833] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.884] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.884] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.936] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.936] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.988] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:31.988] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.040] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.040] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.091] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.091] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:32.112] mining block. block 510. total 0: pending 0(added 0), local 0(added 0), queued 6561
+    tx_pool_test.go:4127: [12:15:32.143] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.144] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.195] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.196] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.247] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.247] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.298] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.299] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.351] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.352] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.402] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.403] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.453] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.454] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.507] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.507] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.559] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.559] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.610] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.610] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.661] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.661] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.713] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.714] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.766] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.767] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.818] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.819] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.871] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.871] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.922] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.923] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.974] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:32.975] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.025] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.025] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.078] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.078] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:33.112] mining block. block 511. total 0: pending 0(added 0), local 0(added 0), queued 6573
+    tx_pool_test.go:4127: [12:15:33.130] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.130] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.182] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.182] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.234] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.237] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.286] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.288] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.337] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.339] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.388] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.390] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.441] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.441] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.492] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.493] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.549] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.549] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.600] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.600] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.652] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.652] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.704] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.704] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.756] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.757] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.809] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.810] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.861] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.862] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.913] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.913] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.964] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:33.965] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.016] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.016] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.069] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.069] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:34.112] mining block. block 512. total 0: pending 0(added 0), local 0(added 0), queued 6586
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.119] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.119] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.171] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.171] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.221] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.221] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.273] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.273] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.326] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.327] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.379] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.380] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.431] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.432] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.483] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.483] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.534] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.535] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.585] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.586] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.637] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.637] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.689] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.690] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.740] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.741] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.793] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.793] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.845] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.845] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.896] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.896] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.948] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.948] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:34.999] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.001] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.052] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.052] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.105] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.106] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:35.111] mining block. block 513. total 0: pending 0(added 0), local 0(added 0), queued 6599
+    tx_pool_test.go:4127: [12:15:35.158] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.158] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.210] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.212] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.263] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.264] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.317] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.318] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.369] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.370] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.421] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.422] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.472] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.473] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.524] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.524] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.578] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.579] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.631] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.631] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.682] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.682] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.733] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.734] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.786] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.787] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.837] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.839] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.889] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.890] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.941] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.941] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.991] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:35.992] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.044] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.047] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.097] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.098] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:36.111] mining block. block 514. total 0: pending 0(added 0), local 0(added 0), queued 6611
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.150] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.150] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.201] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.202] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.254] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.254] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.305] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.306] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.358] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.358] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.409] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.410] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.461] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.462] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.514] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.514] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.566] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.568] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.619] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.619] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.671] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.671] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.724] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.725] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.776] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.776] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.826] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.827] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.877] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.879] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.929] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.929] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.982] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:36.982] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.033] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.034] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.086] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.087] AddRemotes error: txpool is full
+    tx_pool_test.go:3722: [12:15:37.111] mining block. block 515. total 0: pending 0(added 0), local 0(added 0), queued 6624
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.138] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.139] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.190] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.190] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.241] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.242] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.294] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.294] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.345] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.346] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.399] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.401] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.451] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.453] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.502] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.503] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.555] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.556] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.607] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.608] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.659] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.660] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.713] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.713] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.767] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.767] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.819] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.821] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.872] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.872] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.923] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.923] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.975] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:37.975] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.027] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.028] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.079] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.080] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:38.110] mining block. block 516. total 0: pending 0(added 0), local 0(added 0), queued 6636
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.132] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.132] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.184] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.184] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.235] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.235] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.286] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.286] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.338] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.338] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.391] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.391] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.443] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.444] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.495] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.495] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.545] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.545] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.597] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.597] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.649] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.649] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.701] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.701] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.753] AddRemotes error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.753] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.805] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.805] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.858] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.858] AddRemotes error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4118: [12:15:38.909] stop AddRemotes
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.910] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:38.961] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.013] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.064] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:39.112] mining block. block 517. total 0: pending 0(added 0), local 0(added 0), queued 6647
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.115] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.165] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.217] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.269] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.322] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.375] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.428] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.478] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.530] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.583] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.637] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.688] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.739] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.791] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.843] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.895] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.946] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:39.997] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.050] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.103] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:40.110] mining block. block 518. total 0: pending 0(added 0), local 0(added 0), queued 6659
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.156] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.207] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.260] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.313] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.365] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.417] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.470] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.521] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.575] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.626] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.677] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.729] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.780] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.832] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.885] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.936] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:40.986] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.037] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.089] AddRemotesSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:41.112] mining block. block 519. total 0: pending 0(added 0), local 0(added 0), queued 6672
+    tx_pool_test.go:4127: [12:15:41.140] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.193] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.245] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.300] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.352] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.404] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.454] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.506] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.557] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.610] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.662] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.716] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.767] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.818] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.870] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.922] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4127: [12:15:41.974] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4127: [12:15:42.026] AddRemotesSync error: txpool is full
+    tx_pool_test.go:4118: [12:15:42.076] stop AddRemotesSync
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:42.112] mining block. block 520. total 0: pending 0(added 0), local 0(added 0), queued 6682
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:43.112] mining block. block 521. total 0: pending 0(added 0), local 0(added 0), queued 6694
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:44.112] mining block. block 522. total 0: pending 0(added 0), local 0(added 0), queued 6708
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:45.112] mining block. block 523. total 0: pending 0(added 0), local 0(added 0), queued 6718
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:46.111] mining block. block 524. total 0: pending 0(added 0), local 0(added 0), queued 6730
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:47.110] mining block. block 525. total 0: pending 0(added 0), local 0(added 0), queued 6745
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:48.112] mining block. block 526. total 0: pending 0(added 0), local 0(added 0), queued 6758
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:49.110] mining block. block 527. total 0: pending 0(added 0), local 0(added 0), queued 6770
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:50.110] mining block. block 528. total 0: pending 0(added 0), local 0(added 0), queued 6782
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:51.112] mining block. block 529. total 0: pending 0(added 0), local 0(added 0), queued 6794
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:52.111] mining block. block 530. total 0: pending 0(added 0), local 0(added 0), queued 6807
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:53.110] mining block. block 531. total 0: pending 0(added 0), local 0(added 0), queued 6821
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:54.110] mining block. block 532. total 0: pending 0(added 0), local 0(added 0), queued 6834
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:55.110] mining block. block 533. total 0: pending 0(added 0), local 0(added 0), queued 6848
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:56.110] mining block. block 534. total 0: pending 0(added 0), local 0(added 0), queued 6860
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:57.110] mining block. block 535. total 0: pending 0(added 0), local 0(added 0), queued 6873
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:15:58.110] mining block. block 536. total 0: pending 0(added 0), local 0(added 0), queued 6886
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:15:59.111] mining block. block 537. total 0: pending 0(added 0), local 0(added 0), queued 6898
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:00.110] mining block. block 538. total 0: pending 0(added 0), local 0(added 0), queued 6911
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:01.110] mining block. block 539. total 0: pending 0(added 0), local 0(added 0), queued 6922
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:02.111] mining block. block 540. total 0: pending 0(added 0), local 0(added 0), queued 6936
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:03.111] mining block. block 541. total 0: pending 0(added 0), local 0(added 0), queued 6948
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:04.112] mining block. block 542. total 0: pending 0(added 0), local 0(added 0), queued 6958
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:05.111] mining block. block 543. total 0: pending 0(added 0), local 0(added 0), queued 6972
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:06.111] mining block. block 544. total 0: pending 0(added 0), local 0(added 0), queued 6986
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:07.110] mining block. block 545. total 0: pending 0(added 0), local 0(added 0), queued 6999
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:08.111] mining block. block 546. total 0: pending 0(added 0), local 0(added 0), queued 7012
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:09.111] mining block. block 547. total 0: pending 0(added 0), local 0(added 0), queued 7023
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:10.111] mining block. block 548. total 0: pending 0(added 0), local 0(added 0), queued 7035
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:11.110] mining block. block 549. total 0: pending 0(added 0), local 0(added 0), queued 7049
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:12.112] mining block. block 550. total 0: pending 0(added 0), local 0(added 0), queued 7061
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:13.112] mining block. block 551. total 0: pending 0(added 0), local 0(added 0), queued 7075
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:14.112] mining block. block 552. total 0: pending 0(added 0), local 0(added 0), queued 7087
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:15.110] mining block. block 553. total 0: pending 0(added 0), local 0(added 0), queued 7103
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:16.111] mining block. block 554. total 0: pending 0(added 0), local 0(added 0), queued 7120
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:17.110] mining block. block 555. total 0: pending 0(added 0), local 0(added 0), queued 7134
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:18.112] mining block. block 556. total 0: pending 0(added 0), local 0(added 0), queued 7147
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:19.110] mining block. block 557. total 0: pending 0(added 0), local 0(added 0), queued 7162
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:20.111] mining block. block 558. total 0: pending 0(added 0), local 0(added 0), queued 7175
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:21.111] mining block. block 559. total 0: pending 0(added 0), local 0(added 0), queued 7185
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:22.111] mining block. block 560. total 0: pending 0(added 0), local 0(added 0), queued 7199
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:23.111] mining block. block 561. total 0: pending 0(added 0), local 0(added 0), queued 7211
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:24.111] mining block. block 562. total 0: pending 0(added 0), local 0(added 0), queued 7224
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:25.110] mining block. block 563. total 0: pending 0(added 0), local 0(added 0), queued 7240
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:26.110] mining block. block 564. total 0: pending 0(added 0), local 0(added 0), queued 7252
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:27.111] mining block. block 565. total 0: pending 0(added 0), local 0(added 0), queued 7264
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:28.109] mining block. block 566. total 0: pending 0(added 0), local 0(added 0), queued 7278
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:29.111] mining block. block 567. total 0: pending 0(added 0), local 0(added 0), queued 7292
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:30.111] mining block. block 568. total 0: pending 0(added 0), local 0(added 0), queued 7306
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:31.112] mining block. block 569. total 0: pending 0(added 0), local 0(added 0), queued 7318
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:32.111] mining block. block 570. total 0: pending 0(added 0), local 0(added 0), queued 7331
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:33.111] mining block. block 571. total 0: pending 0(added 0), local 0(added 0), queued 7344
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:34.111] mining block. block 572. total 0: pending 0(added 0), local 0(added 0), queued 7356
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:35.111] mining block. block 573. total 0: pending 0(added 0), local 0(added 0), queued 7368
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:36.111] mining block. block 574. total 0: pending 0(added 0), local 0(added 0), queued 7381
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:37.110] mining block. block 575. total 0: pending 0(added 0), local 0(added 0), queued 7394
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:38.111] mining block. block 576. total 0: pending 0(added 0), local 0(added 0), queued 7408
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:39.111] mining block. block 577. total 0: pending 0(added 0), local 0(added 0), queued 7419
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:40.110] mining block. block 578. total 0: pending 0(added 0), local 0(added 0), queued 7433
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:41.111] mining block. block 579. total 0: pending 0(added 0), local 0(added 0), queued 7445
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:42.111] mining block. block 580. total 0: pending 0(added 0), local 0(added 0), queued 7457
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:43.111] mining block. block 581. total 0: pending 0(added 0), local 0(added 0), queued 7469
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:44.111] mining block. block 582. total 0: pending 0(added 0), local 0(added 0), queued 7482
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:45.111] mining block. block 583. total 0: pending 0(added 0), local 0(added 0), queued 7495
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:46.110] mining block. block 584. total 0: pending 0(added 0), local 0(added 0), queued 7507
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:47.111] mining block. block 585. total 0: pending 0(added 0), local 0(added 0), queued 7518
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:48.110] mining block. block 586. total 0: pending 0(added 0), local 0(added 0), queued 7532
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:3722: [12:16:49.111] mining block. block 587. total 0: pending 0(added 0), local 0(added 0), queued 7543
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:50.112] mining block. block 588. total 0: pending 0(added 0), local 0(added 0), queued 7554
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:3722: [12:16:51.111] mining block. block 589. total 0: pending 0(added 0), local 0(added 0), queued 7567
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
+    tx_pool_test.go:4148: AddRemote error: txpool is full
+panic: test timed out after 10m0s
+
+goroutine 76959 [running]:
+testing.(*M).startAlarm.func1()
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:2036 +0xb4
+created by time.goFunc
+	/Users/jekamas/go/go1.19.2/src/time/sleep.go:176 +0x48
+
+goroutine 1 [chan receive, 10 minutes]:
+testing.(*T).Run(0xc000103380, {0x100bce526, 0x17}, 0x100f17d50)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1494 +0x57c
+testing.runTests.func1(0x0?)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1846 +0x94
+testing.tRunner(0xc000103380, 0xc0005afb98)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1446 +0x18c
+testing.runTests(0xc000368500?, {0x1013df840, 0x88, 0x88}, {0xc0001ef0b0?, 0x1002ff280?, 0x1013ec2e0?})
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1844 +0x6c4
+testing.(*M).Run(0xc000368500)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1726 +0x874
+main.main()
+	_testmain.go:407 +0x300
+
+goroutine 4 [chan receive]:
+github.com/ethereum/go-ethereum/metrics.(*meterArbiter).tick(0x1013ebda0)
+	/Users/jekamas/projects/bor/metrics/meter.go:290 +0x7c
+created by github.com/ethereum/go-ethereum/metrics.NewMeterForced
+	/Users/jekamas/projects/bor/metrics/meter.go:71 +0x138
+
+goroutine 5 [select]:
+github.com/ethereum/go-ethereum/consensus/ethash.(*remoteSealer).loop(0xc00035e000)
+	/Users/jekamas/projects/bor/consensus/ethash/sealer.go:280 +0x248
+created by github.com/ethereum/go-ethereum/consensus/ethash.startRemoteSealer
+	/Users/jekamas/projects/bor/consensus/ethash/sealer.go:264 +0x4fc
+
+goroutine 13 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 14 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 15 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 16 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 50 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 51 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 52 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 53 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 54 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 55 [chan receive, 10 minutes]:
+github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
+	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
+created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
+	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
+
+goroutine 56 [chan receive, 10 minutes]:
+testing.(*T).Run(0xc000103520, {0xc00002838a, 0x6}, 0xc0000e7920)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1494 +0x57c
+github.com/ethereum/go-ethereum/core.TestPoolMiningDataRaces(0xc000103520)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3754 +0x294
+testing.tRunner(0xc000103520, 0x100f17d50)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1446 +0x18c
+created by testing.(*T).Run
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1493 +0x560
+
+goroutine 57 [chan receive]:
+github.com/ethereum/go-ethereum/core.apiWithMining({0x100f27e20, 0xc000103860}, {0x100bc5ae4, 0xd}, 0x2710, {{0xc00002838a?, 0xc000069de8?}, 0x10022dd44?}, 0x2540be400, 0xa, ...)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4103 +0x2afc
+github.com/ethereum/go-ethereum/core.TestPoolMiningDataRaces.func1(0xc000103860)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3769 +0xf0
+testing.tRunner(0xc000103860, 0xc0000e7920)
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1446 +0x18c
+created by testing.(*T).Run
+	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1493 +0x560
+
+goroutine 58 [select]:
+github.com/ethereum/go-ethereum/core.(*TxPool).scheduleReorgLoop(0xc000024480)
+	/Users/jekamas/projects/bor/core/tx_pool.go:1413 +0x3d8
+created by github.com/ethereum/go-ethereum/core.NewTxPool
+	/Users/jekamas/projects/bor/core/tx_pool.go:336 +0xb04
+
+goroutine 59 [select]:
+github.com/ethereum/go-ethereum/core.(*TxPool).loop(0xc000024480)
+	/Users/jekamas/projects/bor/core/tx_pool.go:380 +0x338
+created by github.com/ethereum/go-ethereum/core.NewTxPool
+	/Users/jekamas/projects/bor/core/tx_pool.go:353 +0xe78
+
+goroutine 60 [sleep]:
+time.Sleep(0x2faf080)
+	/Users/jekamas/go/go1.19.2/src/runtime/time.go:195 +0x118
+github.com/ethereum/go-ethereum/core.apiWithMining.func2()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3901 +0x35c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
+
+goroutine 62 [sleep]:
+time.Sleep(0x2faf080)
+	/Users/jekamas/go/go1.19.2/src/runtime/time.go:195 +0x118
+github.com/ethereum/go-ethereum/core.addTransactions({0x100f27e20, 0xc000103860}, {0xc000784000, 0x2710, 0x0?}, 0xc0039f0000, 0x0?, 0x0?, 0x0?, {0x100bc2e58, ...}, ...)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4152 +0x258
+github.com/ethereum/go-ethereum/core.apiWithMining.func4()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
+
+goroutine 64 [sleep]:
+time.Sleep(0x2faf080)
+	/Users/jekamas/go/go1.19.2/src/runtime/time.go:195 +0x118
+github.com/ethereum/go-ethereum/core.addTransactions({0x100f27e20, 0xc000103860}, {0xc0007fc000, 0x2710, 0x0?}, 0xc001072050, 0x0?, 0x0?, 0x0?, {0x100bc5b80, ...}, ...)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4155 +0x21c
+github.com/ethereum/go-ethereum/core.apiWithMining.func6()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
+
+goroutine 65 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 66 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 67 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 68 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 69 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 70 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 71 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 72 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 73 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 74 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 75 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 76 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 77 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 78 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x0)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 79 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 80 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 81 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 82 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 83 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 84 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 85 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 86 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 87 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 88 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 89 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 90 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 91 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 92 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x1)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 93 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 94 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 95 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 96 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 97 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 114 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 115 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 116 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 117 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 118 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 119 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 120 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 121 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 122 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x2)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 123 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 124 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 125 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 126 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 127 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 128 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 129 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 130 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 131 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 132 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 133 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 134 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 135 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 136 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x3)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 137 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 138 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 139 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 140 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 141 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 142 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 143 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 144 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 145 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 146 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 147 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 148 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 149 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 150 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x4)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 151 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 152 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 153 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 154 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 155 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 156 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 157 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 158 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 159 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 160 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 161 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 178 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 179 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 180 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x5)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 181 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 182 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 183 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x2faf080?, 0x100f27e20?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 184 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x2540be400?, 0x2faf080?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 185 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x2faf080?, 0x100f27e20?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 186 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 187 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 188 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 189 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 190 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 191 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 192 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 193 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 194 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x6)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 195 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 196 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x2faf080?, 0x100f27e20?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 197 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x2faf080?, 0x100f27e20?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 198 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 199 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x2540be400?, 0x2faf080?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 200 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 201 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 202 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 203 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 204 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 205 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 206 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 207 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 208 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x7)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 209 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 210 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x2540be400?, 0x2faf080?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 211 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 212 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 213 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 214 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 215 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 216 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 217 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 218 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 219 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 220 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 221 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 222 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x8)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+
+goroutine 223 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func7()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
+
+goroutine 224 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func8()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
+
+goroutine 225 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func9()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
+
+goroutine 226 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func10()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
+
+goroutine 227 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func11()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
+
+goroutine 228 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func12()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
+
+goroutine 229 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func13()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
+
+goroutine 230 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func14()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
+
+goroutine 231 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func15()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
+
+goroutine 232 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func16()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
+
+goroutine 233 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func17()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
+
+goroutine 234 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func18()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
+
+goroutine 235 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func19()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
+
+goroutine 236 [chan receive, 9 minutes]:
+github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x9)
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
+github.com/ethereum/go-ethereum/core.apiWithMining.func20()
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
+created by github.com/ethereum/go-ethereum/core.apiWithMining
+	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
+FAIL	github.com/ethereum/go-ethereum/core	600.860s
+FAIL
+make: *** [test-txpool-race] Error 1

From 6165eec6770339c5a38f4a037818f5a29c94aee8 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Thu, 10 Nov 2022 16:30:47 +0400
Subject: [PATCH 85/96] debug

---
 .github/workflows/main.go | 40 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 .github/workflows/main.go

diff --git a/.github/workflows/main.go b/.github/workflows/main.go
new file mode 100644
index 0000000000..47d1a9f327
--- /dev/null
+++ b/.github/workflows/main.go
@@ -0,0 +1,40 @@
+// You can edit this code!
+// Click here and start typing.
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	var (
+		tickerCount int
+		loopCount   int
+	)
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop() // please add this to prevent memory leak - https://stackoverflow.com/questions/68289916/will-time-tick-cause-memory-leak-when-i-never-need-to-stop-it
+
+	done := make(chan struct{})
+	loopCh := make(chan struct{})
+
+	go func() {
+		for range ticker.C {
+			fmt.Println("! ticker", tickerCount)
+			tickerCount++
+
+			select {
+			case <-done:
+			default:
+				close(done) // it is not correct for multiple goroutines, only for example
+			}
+		}
+	}()
+
+	time.Sleep(4 * time.Second)
+	close(loopCh)
+	<-done
+
+	fmt.Println("DONE", tickerCount, loopCount)
+}

From 737d7e6260bebe8ac1872e9b149a44ea0a021206 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 00:31:15 +0400
Subject: [PATCH 86/96] fix ticker

---
 .github/workflows/main.go |     40 -
 sync.txt                  | 201694 -----------------------------------
 test1.txt                 |   5602 -
 3 files changed, 207336 deletions(-)
 delete mode 100644 .github/workflows/main.go
 delete mode 100644 sync.txt
 delete mode 100644 test1.txt

diff --git a/.github/workflows/main.go b/.github/workflows/main.go
deleted file mode 100644
index 47d1a9f327..0000000000
--- a/.github/workflows/main.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// You can edit this code!
-// Click here and start typing.
-package main
-
-import (
-	"fmt"
-	"time"
-)
-
-func main() {
-	var (
-		tickerCount int
-		loopCount   int
-	)
-
-	ticker := time.NewTicker(time.Second)
-	defer ticker.Stop() // please add this to prevent memory leak - https://stackoverflow.com/questions/68289916/will-time-tick-cause-memory-leak-when-i-never-need-to-stop-it
-
-	done := make(chan struct{})
-	loopCh := make(chan struct{})
-
-	go func() {
-		for range ticker.C {
-			fmt.Println("! ticker", tickerCount)
-			tickerCount++
-
-			select {
-			case <-done:
-			default:
-				close(done) // it is not correct for multiple goroutines, only for example
-			}
-		}
-	}()
-
-	time.Sleep(4 * time.Second)
-	close(loopCh)
-	<-done
-
-	fmt.Println("DONE", tickerCount, loopCount)
-}
diff --git a/sync.txt b/sync.txt
deleted file mode 100644
index cff94a1071..0000000000
--- a/sync.txt
+++ /dev/null
@@ -1,201694 +0,0 @@
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc00618a000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00477c000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc00618a000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc0048c0000, 0x4000, 0x4000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc00618a000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002413928?, 0x3c?, 0xc002413958?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).Fail(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:820 +0x64
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beee10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:941 +0x8c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006386000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002411888?, 0x3c?, 0xc0024118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00687e000, 0x24025}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeeb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc006a3c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc00637e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc0064be000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc0064be000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0065be000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc00755c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc007264000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc006b04000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0074a8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc006b0c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc006b68000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc006c6c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc006a4c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc006fd2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc006fb2000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc006c44000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc006e60000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc006682000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc007264000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc006b04000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc00699c000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0074a8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00723c000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc006e9e000, 0x8000, 0x8000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c98a8?, 0x3c?, 0xc0040c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006918000, 0x23fae}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc006919721, 0x3e})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [runnable]:
-        fmt.(*pp).free(0xc002450000)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc00691a9db, 0x3d})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc00691b7b1, 0x80})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc00691e2b4, 0xbc})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc006920d82, 0xbd})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc006924703, 0x3e})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [runnable]:
-        time.Time.Format({0xc0036eeaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc00692d5ff, 0x9f})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc00692803d, 0x90})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc00019a2b0, {0xc005fb6000, 0x25cfa})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc00011e110, {0x104d96da6, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc007d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc007cd6000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc007d06000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc00692d5ff, 0x9f})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc0022c21e0, {0xc0062ec000, 0x232f2})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc0069348a1, 0x32})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0xc0069361a3, 0x1b})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [runnable]:
-        fmt.(*pp).free(0xc0022c21a0)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteString(0xc004696040, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        strings.(*Builder).WriteByte(0xc004696040, 0xa)
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:96 +0x1a4
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:683 +0x288
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        os.(*File).Write(0xc000120008, {0xc006894000, 0x28588, 0x2a000})
-        	/Users/jekamas/go/go1.19.2/src/os/file.go:171 +0x410
-        fmt.Fprintf({0x1050f5e60, 0xc000120008}, {0x104d95c29, 0x2}, {0xc0040c9a48, 0x1, 0x1})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:205 +0x98
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [runnable]:
-        fmt.glob..func1()
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:132 +0x2c
-        sync.(*Pool).Get(0x1055aa560)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:151 +0x12c
-        fmt.newPrinter()
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:137 +0x2c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:218 +0x38
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        syscall.syscall(0x104d5ad24?, 0x10680ba00?, 0x106544408?, 0x0?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sys_darwin.go:22 +0x54
-        syscall.write(0xc0040c9668?, {0xc006894000, 0x28588, 0x0?})
-        	/Users/jekamas/go/go1.19.2/src/syscall/zsyscall_darwin_arm64.go:1653 +0x64
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*pp).doPrintf(0xc004c5e0d0, {0x104dc934d, 0x43}, {0xc003984000?, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:1018 +0x13c
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        runtime.Stack({0xc008916000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        runtime.Stack({0xc0082e6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 200 [semacquire]:
-        runtime.Stack({0xc0088b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc008ade000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0089fe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc008956000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [runnable]:
-        fmt.(*pp).doPrintf(0xc00011edd0, {0x104dc39f9, 0x34}, {0xc0040a08c0?, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:1005 +0x157c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:219 +0x54
---
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [GC assist wait]:
-        testing.(*common).frameSkip(0xc0004704e0, 0x4)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:586 +0x90
-        testing.(*common).decorate(0xc0004704e0?, {0xc006918000, 0x23fae}, 0xc006918000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:652 +0x44
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc004bf4918?, 0x3c?, 0xc004bf4948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068f2000, 0x240d7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        runtime.Stack({0xc0083b6000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [GC assist wait]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc0088f6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc008a3e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        runtime.Stack({0xc008ade000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0089fe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc008abe000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc008a9e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc008b7e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc008d46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc008b1e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc008d66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc008c42000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ab8000, 0x2467f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beefa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34110, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 199 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        runtime.Stack({0xc008eca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc008e06000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.genSplit({0xc006ab8000, 0x2467f}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:250 +0x8c
-        strings.Split(...)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc008e66000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc008e46000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc008da6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc008de6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0xc006ab9200, 0x37})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc008f6e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc00011f560, {0xc00956e000, 0x2b26d})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0xc006abadc9, 0x3d})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 98 [semacquire]:
-        runtime.Stack({0xc009120000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0xc006ac801a, 0x3d})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc00453c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        runtime.Stack({0xc0044fc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 80 [semacquire]:
-        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [runnable]:
-        fmt.(*pp).free(0xc00011f6c0)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        runtime.Stack({0xc009032000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        runtime.Stack({0xc005bba000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0xc006acd5cf, 0xbc})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        runtime.Stack({0xc009120000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc00455c000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0xc006ad487d, 0x3b})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        runtime.Stack({0xc009120000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc005b5a000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        strings.(*Builder).WriteString(0xc004642020, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:122 +0x1d8
-        testing.(*common).decorate(0xc0004704e0?, {0xc006ab8000, 0x2467f}, 0xc006ab8000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        os.(*File).Write(0xc000120008, {0xc009c40000, 0x28d59, 0x2a000})
-        	/Users/jekamas/go/go1.19.2/src/os/file.go:171 +0x410
-        fmt.Fprintf({0x1050f5e60, 0xc000120008}, {0x104d95c29, 0x2}, {0xc0040cba48, 0x1, 0x1})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:205 +0x98
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        runtime.Stack({0xc0091a0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc0022c2930, {0xc009aca000, 0x28d59})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        runtime.Stack({0xc009160000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        runtime.Stack({0xc005bfa000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [runnable]:
-        fmt.(*fmt).padString(0xc0040f6520, {0xc009d04000, 0x2c8b7})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:108 +0x3c0
-        fmt.(*fmt).fmtS(0xc0040f6520, {0xc009d04000, 0x2c8b7})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:359 +0x7c
---
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030f9888?, 0x3c?, 0xc0030f98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bc6000, 0x24941}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004beeff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        runtime.Stack({0xc00932c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [runnable]:
-        syscall.syscall(0x104d5ad24?, 0x106818300?, 0x106544408?, 0x0?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sys_darwin.go:22 +0x54
-        syscall.write(0xc0040cb668?, {0xc009c40000, 0x28d59, 0x0?})
-        	/Users/jekamas/go/go1.19.2/src/syscall/zsyscall_darwin_arm64.go:1653 +0x64
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc005d72000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc005d52000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc005db8000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        runtime.Stack({0xc005e18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [runnable]:
-        fmt.(*pp).free(0xc00011fad0)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
---
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc0022c2a00, {0xc00a234000, 0x2c921})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00614e000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        runtime.Stack({0xc0064c6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [runnable]:
-        fmt.(*pp).free(0xc0022c29c0)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:146 +0x15c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:221 +0x8c
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        runtime.Stack({0xc0062cc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        runtime.Stack({0xc00650e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 188 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 208 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        runtime.Stack({0xc0066bc000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc006874000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        runtime.Stack({0xc006704000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 211 [semacquire]:
-        runtime.Stack({0xc009240000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        runtime.Stack({0xc006674000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [runnable]:
-        runtime.Gosched(...)
-        	/Users/jekamas/go/go1.19.2/src/runtime/proc.go:318
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 139 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 178 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [GC assist wait]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [GC assist wait]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc0025e86c0, {0xc00b5ea000, 0x2ac38})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 142 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 202 [semacquire]:
-        runtime.Stack({0xc0097ce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [GC assist wait]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [GC assist wait]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc0025e86c0, {0xc00b5ea000, 0x2ac38})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 181 [semacquire]:
-        runtime.Stack({0xc007844000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 155 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        runtime.Stack({0xc007360000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc006ba6000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 220 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 150 [semacquire]:
-        runtime.Stack({0xc009eb2000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 222 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0a0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        runtime.Stack({0xc0076ca000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        runtime.Stack({0xc007560000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 196 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 113 [semacquire]:
-        runtime.Stack({0xc009f4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 205 [semacquire]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        time.Time.Format({0xc005b28af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        time.Time.Format({0xc004bf0af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        time.Time.Format({0xc0030a8ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 96 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        time.Time.Format({0xc000be8ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        time.Time.Format({0xc004c45af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        time.Time.Format({0xc005b36af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
---
-        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 143 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        time.Time.Format({0xc0030c6af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*pp).doPrintf(0xc0022c2000, {0x104dc39f9, 0x34}, {0xc00222e000?, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:1018 +0x18c
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        time.Time.Format({0xc0040a9af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc00a8dc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 188 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        time.Time.Format({0xc004c48af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        time.Time.Format({0xc0036eaad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        time.Time.Format({0xc0036e9ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        time.Time.Format({0xc00229aad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [runnable]:
-        fmt.(*pp).fmtInteger(0xc00260c000, 0x7?, 0x1, 0x64)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:401 +0x264
-        fmt.(*pp).printArg(0xc00260c000, {0x104ff9980?, 0x1055809d8}, 0x64)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:703 +0x8ac
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        time.Time.Format({0xc0040a7af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc0025e86c0, {0xc00b5ea000, 0x2ac38})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        time.Time.Format({0xc002424af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        runtime.Stack({0xc00a95c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        runtime.Stack({0xc0078ac000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        runtime.Stack({0xc0078ec000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 192 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 148 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc00792c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 110 [semacquire]:
-        runtime.Stack({0xc009e44000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        runtime.Stack({0xc0092c0000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        runtime.Stack({0xc009280000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 78 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22030, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x126315300b5c4be8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x8d844fea542bd4c0?, {0x104d96da6, 0x5}, 0xffffffffffffffff?, 0x437e2838ecedf676?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 73 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 68 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        time.Time.Format({0xc005b28af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        time.Time.Format({0xc004bf0af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        time.Time.Format({0xc0030a8ad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c5d8a8?, 0x3c?, 0xc000c5d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ef6000, 0x2afbb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 85 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 96 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d9888?, 0x3c?, 0xc0037d98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005fb6000, 0x2c764}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 104 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        time.Time.Format({0xc004c45af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e78a8?, 0x3c?, 0xc0010e78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b76e000, 0x29a4c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde020, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe41a0ae05b327e52?, 0xccb003e040557d96?, {0x104d99fcb, 0x8}, 0xea4f35e83d4779ac?, 0xc09a03772fe97cf0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 131 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cf8a8?, 0x3c?, 0xc0037cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0060fc000, 0x2ca93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0c0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x30f0a0b030d0c?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x74f63f51cbac4c35?, 0x7bebb4f219b7fcfd?, {0x104d9c53b, 0xb}, 0xba192169bf4389e5?, 0x50eb46bed0436478?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 132 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c98a8?, 0x3c?, 0xc0037c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005c90000, 0x2ab8d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 139 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038a78a8?, 0x3c?, 0xc0038a78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0045a8000, 0x2b732}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 140 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0006658a8?, 0x3c?, 0xc0006658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005de0000, 0x2b55b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 142 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 143 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000663888?, 0x3c?, 0xc0006638b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006220000, 0x2b0d9}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 150 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x462154a84dbff288?, {0x104d96da6, 0x5}, 0xc2a3fb52904c6a09?, 0x42f9909cf99263d1?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00388b8a8?, 0x3c?, 0xc00388b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0060d0000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 155 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037f7888?, 0x3c?, 0xc0037f78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005c64000, 0x2bac2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 178 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cb8a8?, 0x3c?, 0xc0037cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f50000, 0x2c84f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 181 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc00a8dc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 188 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        time.Time.Format({0xc004c48af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [runnable]:
-        time.Time.Format({0xc0036eaad8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002761888?, 0x3c?, 0xc0027618b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006278000, 0x2c937}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 196 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c618a8?, 0x3c?, 0xc000c618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d88000, 0x2aedf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x66f66ad030295201?, 0x4e8269c18f707ffb?, {0x104da355c, 0x14}, 0xe245c7bcc1a4860a?, 0x84b09ee8ae152305?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 197 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0006618a8?, 0x3c?, 0xc0006618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005db4000, 0x2b1c8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 202 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa100, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x60dd51c1a28748f5?, 0x2ae8e60c20f6807e?, {0x104d99fcb, 0x8}, 0x82f35a4d2cfef6a?, 0x9a81dc1c4ef13c4c?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038a9888?, 0x3c?, 0xc0038a98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005be0000, 0x2b38c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 208 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024658a8?, 0x3c?, 0xc0024658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005bb2000, 0x2cf7c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 211 [runnable]:
-        time.Time.Format({0xc000bfaaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002463888?, 0x3c?, 0xc0024638b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00619a000, 0x2ac73}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 220 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037eb888?, 0x3c?, 0xc0037eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00624c000, 0x2b2a5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 222 [semacquire]:
-        time.Time.Format({0xc000bfeaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        time.Time.Format({0xc002424af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 125 [select]:
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20.1(0xc0024189c0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4079 +0xac
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4214 +0x21c
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        runtime.Stack({0xc009398000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        runtime.Stack({0xc00635e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 190 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 84 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        runtime.Stack({0xc006a04000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        runtime.Stack({0xc007086000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        runtime.Stack({0xc009442000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        runtime.Stack({0xc006c18000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        runtime.Stack({0xc00969e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        runtime.Stack({0xc009736000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        runtime.Stack({0xc009606000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        runtime.Stack({0xc00952e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        runtime.Stack({0xc0094ee000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        runtime.Stack({0xc007192000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        runtime.Stack({0xc009482000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 229 [semacquire]:
-        runtime.Stack({0xc00a07c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006804000, 0x2c119}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be47d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be47d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c5d8a8?, 0x3c?, 0xc000c5d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ef6000, 0x2afbb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 85 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 96 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d9888?, 0x3c?, 0xc0037d98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005fb6000, 0x2c764}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 104 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xb3991336a2ee113c?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037e98a8?, 0x3c?, 0xc0037e98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0089b6000, 0x2c206}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 110 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092040, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0022d2f00?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9?, 0xc0039bd260?, {0x104da0b46, 0x11}, 0xc0039bd500?, 0x6?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024698a8?, 0x3c?, 0xc0024698d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0064b6000, 0x2c681}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 113 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0d0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb9512736602a5dfc?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x79c2e1f7d5932de3?, 0x1265a686a452d8c0?, {0x104d9f0db, 0xf}, 0x6e8c12fa5961f9cd?, 0x4120603dc6d69c26?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e78a8?, 0x3c?, 0xc0010e78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b76e000, 0x29a4c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde020, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe41a0ae05b327e52?, 0xccb003e040557d96?, {0x104d99fcb, 0x8}, 0xea4f35e83d4779ac?, 0xc09a03772fe97cf0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 131 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cf8a8?, 0x3c?, 0xc0037cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0060fc000, 0x2ca93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0c0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x30f0a0b030d0c?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x74f63f51cbac4c35?, 0x7bebb4f219b7fcfd?, {0x104d9c53b, 0xb}, 0xba192169bf4389e5?, 0x50eb46bed0436478?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 132 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d5888?, 0x3c?, 0xc0037d58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006674000, 0x2c4b7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xb1094e773a9c3940?, 0xc3c88717e9453e42?, {0x104d9c341, 0xb}, 0x333a4de91c7dac9?, 0x1?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 133 [runnable]:
-        syscall.syscall(0x104d5ad24?, 0x106812000?, 0x106544408?, 0x0?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sys_darwin.go:22 +0x54
-        syscall.write(0xc0030f9648?, {0xc0064e4000, 0x2907b, 0x0?})
-        	/Users/jekamas/go/go1.19.2/src/syscall/zsyscall_darwin_arm64.go:1653 +0x64
---
-        sync.runtime_SemacquireMutex(0xc0037e7888?, 0x3c?, 0xc0037e78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b44000, 0x2bc90}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b0230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x89cda42b30ed56bc?, 0xe4aa3a086dfc43a6?, {0x104d95edd, 0x3}, 0x0?, 0x50b8a5dae714f931?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 135 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c98a8?, 0x3c?, 0xc0037c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005c90000, 0x2ab8d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 139 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038a78a8?, 0x3c?, 0xc0038a78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0045a8000, 0x2b732}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 140 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0006658a8?, 0x3c?, 0xc0006658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005de0000, 0x2b55b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 142 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 143 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d18a8?, 0x3c?, 0xc0037d18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00654e000, 0x2c59e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 146 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010c1888?, 0x3c?, 0xc0010c18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006a70000, 0x2af07}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 148 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000663888?, 0x3c?, 0xc0006638b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006220000, 0x2b0d9}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 150 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x462154a84dbff288?, {0x104d96da6, 0x5}, 0xc2a3fb52904c6a09?, 0x42f9909cf99263d1?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00388b8a8?, 0x3c?, 0xc00388b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0060d0000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 155 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037f7888?, 0x3c?, 0xc0037f78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005c64000, 0x2bac2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 178 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cb8a8?, 0x3c?, 0xc0037cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f50000, 0x2c84f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 181 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cd888?, 0x3c?, 0xc0037cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006732000, 0x2c3cb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x3f2fbf8d966dae93?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x9f214d9212d7abb8?, {0x104d97bc4, 0x6}, 0x99873abea0229301?, 0x0?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 182 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010c38a8?, 0x3c?, 0xc0010c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066a2000, 0x2d0f7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0f0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc3439c568f92abad?, 0x4ad38caef681d72a?, {0x104da355c, 0x14}, 0x2a284303df5bf8e6?, 0x816567eb32106814?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 183 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        runtime.Stack({0xc00a8dc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 188 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037db888?, 0x3c?, 0xc0037db8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006790000, 0x2c2e3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 192 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002761888?, 0x3c?, 0xc0027618b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006278000, 0x2c937}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 196 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c618a8?, 0x3c?, 0xc000c618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d88000, 0x2aedf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x66f66ad030295201?, 0x4e8269c18f707ffb?, {0x104da355c, 0x14}, 0xe245c7bcc1a4860a?, 0x84b09ee8ae152305?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 197 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0006618a8?, 0x3c?, 0xc0006618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005db4000, 0x2b1c8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 202 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa100, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x60dd51c1a28748f5?, 0x2ae8e60c20f6807e?, {0x104d99fcb, 0x8}, 0x82f35a4d2cfef6a?, 0x9a81dc1c4ef13c4c?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037e5888?, 0x3c?, 0xc0037e58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065e0000, 0x2be68}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 205 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038a9888?, 0x3c?, 0xc0038a98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005be0000, 0x2b38c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 208 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024658a8?, 0x3c?, 0xc0024658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005bb2000, 0x2cf7c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 211 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037f98a8?, 0x3c?, 0xc0037f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006832000, 0x2bf53}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 212 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002463888?, 0x3c?, 0xc0024638b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00619a000, 0x2ac73}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 220 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037eb888?, 0x3c?, 0xc0037eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00624c000, 0x2b2a5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 222 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d78a8?, 0x3c?, 0xc0037d78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006a9c000, 0x2c02e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0a0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 223 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [runnable]:
-        time.Time.Format({0xc002424af8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:609 +0xb8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010bf888?, 0x3c?, 0xc0010bf8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00685e000, 0x2afee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b327d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0150, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x6af358bcb1d9d13b?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2e2ac2be0e0754ac?, 0x87e6aff85ef86711?, {0x104d95eec, 0x3}, 0x89a21b1236da5645?, 0x3e6436d15c2479ba?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 234 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2120, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xa8db55a668ba35ab?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf9a0445d45b635f5?, 0xea709bcf68bb8ea7?, {0x104d95edd, 0x3}, 0x29bab3ca1f705044?, 0xf0edf6feb98874d2?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        runtime.Stack({0xc009982000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 92 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        runtime.Stack({0xc009b4e000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006804000, 0x2c119}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00388d8a8?, 0x3c?, 0xc00388d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008a94000, 0x2bbb5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 68 [runnable]:
-        strings.genSplit({0xc006b70000, 0x245b4}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:250 +0x8c
-        strings.Split(...)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
---
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0011138a8?, 0x3c?, 0xc0011138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008a68000, 0x2ae27}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 73 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c78a8?, 0x3c?, 0xc0037c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b640000, 0x29d93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be45f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 74 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc0005b7588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc003889888?, 0x3c?, 0xc0038898b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0079ac000, 0x2b9dd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b03c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 76 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037fb888?, 0x3c?, 0xc0037fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008a10000, 0x2b811}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 78 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038ab8a8?, 0x3c?, 0xc0038ab8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00780c000, 0x2b8f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22030, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x126315300b5c4be8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x8d844fea542bd4c0?, {0x104d96da6, 0x5}, 0xffffffffffffffff?, 0x437e2838ecedf676?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 6 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00110f8a8?, 0x3c?, 0xc00110f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008b7a000, 0x2ad3c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be47d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 84 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c5d8a8?, 0x3c?, 0xc000c5d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ef6000, 0x2afbb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34030, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 85 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00275f888?, 0x3c?, 0xc00275f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b516000, 0x29f4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308cd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 90 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0040cb8a8?, 0x3c?, 0xc0040cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b696000, 0x29e24}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0xb1434cd23223ee8a?, 0x9ea9febf0d476b0f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 96 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010eb888?, 0x3c?, 0xc0010eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b3c6000, 0x29df1}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc1f5553be043ceed?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf329d2ae7dd6b989?, 0xafbb80dc0154dd4b?, {0x104d9c341, 0xb}, 0x0?, 0xa0e02070d060e0a?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 103 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d9888?, 0x3c?, 0xc0037d98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005fb6000, 0x2c764}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c030, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xa774cbed6e2d2a48?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x59f0b7587e162680?, 0x3a33d1ed9965af4e?, {0x104d95eec, 0x3}, 0x1d0192243b54d468?, 0x4f0704b610443ff3?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 104 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c38a8?, 0x3c?, 0xc0037c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b5c0000, 0x29dbc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1006172b02bd39a?, 0x608ed64dd2200157?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 107 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037e98a8?, 0x3c?, 0xc0037e98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0089b6000, 0x2c206}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 110 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092040, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0022d2f00?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9?, 0xc0039bd260?, {0x104da0b46, 0x11}, 0xc0039bd500?, 0x6?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024698a8?, 0x3c?, 0xc0024698d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0064b6000, 0x2c681}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 113 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0d0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb9512736602a5dfc?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x79c2e1f7d5932de3?, 0x1265a686a452d8c0?, {0x104d9f0db, 0xf}, 0x6e8c12fa5961f9cd?, 0x4120603dc6d69c26?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e78a8?, 0x3c?, 0xc0010e78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b76e000, 0x29a4c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde020, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe41a0ae05b327e52?, 0xccb003e040557d96?, {0x104d99fcb, 0x8}, 0xea4f35e83d4779ac?, 0xc09a03772fe97cf0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 131 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cf8a8?, 0x3c?, 0xc0037cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0060fc000, 0x2ca93}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0c0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x30f0a0b030d0c?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x74f63f51cbac4c35?, 0x7bebb4f219b7fcfd?, {0x104d9c53b, 0xb}, 0xba192169bf4389e5?, 0x50eb46bed0436478?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 132 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d5888?, 0x3c?, 0xc0037d58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006674000, 0x2c4b7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2090, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xb1094e773a9c3940?, 0xc3c88717e9453e42?, {0x104d9c341, 0xb}, 0x333a4de91c7dac9?, 0x1?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 133 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030f97b8?, 0x3c?, 0xc0030f97e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c380a0, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xc93091026869fe32?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x89cf38b107219d04?, {0x104d95eec, 0x3}, 0xb2959e1dc1de797b?, 0x6199f510e9c3f1ce?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 134 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037e7888?, 0x3c?, 0xc0037e78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b44000, 0x2bc90}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b0230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x8090b020d050400?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x89cda42b30ed56bc?, 0xe4aa3a086dfc43a6?, {0x104d95edd, 0x3}, 0x0?, 0x50b8a5dae714f931?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 135 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037c98a8?, 0x3c?, 0xc0037c98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005c90000, 0x2ab8d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf70ecb95bb58b121?, 0x6069d66fe0d85437?, {0x104da355c, 0x14}, 0xec8d32b63131916?, 0x79bb7fbc956c10a8?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 139 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038a78a8?, 0x3c?, 0xc0038a78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0045a8000, 0x2b732}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc00228cf50?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00367be00?, {0x104d9f28e, 0xf}, 0xc0036a6120?, 0x6?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 140 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0006658a8?, 0x3c?, 0xc0006658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005de0000, 0x2b55b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 142 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024678a8?, 0x3c?, 0xc0024678d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b6ec000, 0x299d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b326e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c100, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe4d856f57aefd970?, 0x948553a4d4aeb78a?, {0x104d98c2c, 0x7}, 0x9379c63d5dd44f20?, 0x3ee99806cd01b066?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 143 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0e0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc010d010f0b0608?, 0x80306030c04090a?, {0x104d9f0db, 0xf}, 0x501040301030d02?, 0xe04050c060f0609?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0027638a8?, 0x3c?, 0xc0027638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b2f0000, 0x2d1a7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024085f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xa000e0b06030608?, 0x10?, {0x104d99fcb, 0x8}, 0xb6a1ea0630615510?, 0xca4630dc1443bdc0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 145 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d18a8?, 0x3c?, 0xc0037d18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00654e000, 0x2c59e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac0f0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x227b610505704e21?, 0x1f1816f6afe56e06?, {0x104d9c53b, 0xb}, 0x762979b32bc7144f?, 0xa8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 146 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010c1888?, 0x3c?, 0xc0010c18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006a70000, 0x2af07}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 148 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000663888?, 0x3c?, 0xc0006638b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006220000, 0x2b0d9}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 150 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x462154a84dbff288?, {0x104d96da6, 0x5}, 0xc2a3fb52904c6a09?, 0x42f9909cf99263d1?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00388b8a8?, 0x3c?, 0xc00388b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0060d0000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 155 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037f7888?, 0x3c?, 0xc0037f78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005c64000, 0x2bac2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 178 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cb8a8?, 0x3c?, 0xc0037cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f50000, 0x2c84f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 181 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037cd888?, 0x3c?, 0xc0037cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006732000, 0x2c3cb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x3f2fbf8d966dae93?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x9f214d9212d7abb8?, {0x104d97bc4, 0x6}, 0x99873abea0229301?, 0x0?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 182 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010c38a8?, 0x3c?, 0xc0010c38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066a2000, 0x2d0f7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0f0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc3439c568f92abad?, 0x4ad38caef681d72a?, {0x104da355c, 0x14}, 0x2a284303df5bf8e6?, 0x816567eb32106814?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 183 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 186 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00236f8a8?, 0x3c?, 0xc00236f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00b742000, 0x2b242}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0dc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x62ea135562189f91?, 0xf743778a0f0a7e61?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 188 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037f58a8?, 0x3c?, 0xc0037f58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008af0000, 0x2bd7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 190 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037db888?, 0x3c?, 0xc0037db8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006790000, 0x2c2e3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 192 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002761888?, 0x3c?, 0xc0027618b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006278000, 0x2c937}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 196 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c618a8?, 0x3c?, 0xc000c618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d88000, 0x2aedf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x1fa4e23b5147b5e8?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x66f66ad030295201?, 0x4e8269c18f707ffb?, {0x104da355c, 0x14}, 0xe245c7bcc1a4860a?, 0x84b09ee8ae152305?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 197 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0006618a8?, 0x3c?, 0xc0006618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005db4000, 0x2b1c8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 202 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be4870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037e5888?, 0x3c?, 0xc0037e58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065e0000, 0x2be68}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0030b01e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 205 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00236b888?, 0x3c?, 0xc00236b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a6c0000, 0x2cea7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ccd0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x70f7390c97b2db31?, 0x57ca3405596e7e96?, {0x104d95eec, 0x3}, 0x5fcb5d2c32dfacf9?, 0x2bcc99e3bd63be93?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 206 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0038a9888?, 0x3c?, 0xc0038a98b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005be0000, 0x2b38c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 208 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0024658a8?, 0x3c?, 0xc0024658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005bb2000, 0x2cf7c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 211 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037f98a8?, 0x3c?, 0xc0037f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006832000, 0x2bf53}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 212 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002463888?, 0x3c?, 0xc0024638b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00619a000, 0x2ac73}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95eec, 0x3}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 220 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037eb888?, 0x3c?, 0xc0037eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00624c000, 0x2b2a5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 222 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0037d78a8?, 0x3c?, 0xc0037d78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006a9c000, 0x2c02e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0a0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 223 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010bf888?, 0x3c?, 0xc0010bf8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00685e000, 0x2afee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b327d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0150, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x6af358bcb1d9d13b?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2e2ac2be0e0754ac?, 0x87e6aff85ef86711?, {0x104d95eec, 0x3}, 0x89a21b1236da5645?, 0x3e6436d15c2479ba?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-        
-        goroutine 234 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2120, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xa8db55a668ba35ab?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf9a0445d45b635f5?, 0xea709bcf68bb8ea7?, {0x104d95edd, 0x3}, 0x29bab3ca1f705044?, 0xf0edf6feb98874d2?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c5f8a8?, 0x3c?, 0xc000c5f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008ac0000, 0x2f9a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x591de6f93f64200f?, 0xfa2c477206aeb67b?, {0x104da355c, 0x14}, 0xff81388f0b7a5605?, 0x488c027beda67b6c?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 125 [select]:
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20.1(0xc0024189c0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4079 +0xac
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4214 +0x21c
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 137 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        runtime.Stack({0xc009cc4000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 232 [semacquire]:
-        runtime.Stack({0xc00a2be000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 95 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xf681d059f1046f81?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 214 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        runtime.Stack({0xc00a12a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        runtime.Stack({0xc00a03c000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 153 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        runtime.Stack({0xc00a0bc000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        runtime.Stack({0xc009fce000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 217 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 88 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        runtime.Stack({0xc00a16a000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 101 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22060, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x70fa3173731929d7?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xebbdae21565347d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x447791d47df30201?, 0x837db26626fbf479?, {0x104d99fcb, 0x8}, 0x2a48949233cac0a4?, 0x4aa01d1b5e10956?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf7d8?, 0x3c?, 0xc0030cf808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a20, 0x55}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984ec0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308000, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea0c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0024137d8?, 0x3c?, 0xc002413808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388a80, 0x58}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984fc0, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde000, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc000058da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0030ff8a8?, 0x3c?, 0xc0030ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b70000, 0x245b4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc0000545a8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0x1043ce8e8?, {0x104da0b46, 0x11}, 0xc000054738?, 0x1043c8488?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 69 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c97d8?, 0x3c?, 0xc0040c9808?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002388060, 0x51}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003984000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa060, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x8a5c?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1055c4b1c?, 0xc000053f28?, {0x104d97a38, 0x6}, 0xc000053f38?, 0x1043c843c?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 70 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0017078a8?, 0x3c?, 0xc0017078d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00616e000, 0x2ae17}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34010, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 71 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030d38a8?, 0x3c?, 0xc0030d38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ecc000, 0x24bcc}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228aaf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34000, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc0003b6da8?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 72 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e070, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d99fcb, 0x8}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc002323888?, 0x3c?, 0xc0023238b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005d06000, 0x24aec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b34000, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xc0005ba588?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 77 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2000, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xc0005bad88?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e9848?, 0x3c?, 0xc0010e9878?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc002282060, 0x59}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003920040, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee050, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002211888?, 0x3c?, 0xc0022118b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009b8e000, 0x2b9cf}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x7249c6c3d42bce85?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 80 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022138a8?, 0x3c?, 0xc0022138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a1aa000, 0x2c9c5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cb90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e090, 0xc00035e0c0, {0x104da355c, 0x14}, 0xb83560923c8a200?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x557f7344f9cbd501?, 0xf49882d38abff00f?, {0x104da355c, 0x14}, 0xed071ea16dbd0d98?, 0xb86acc409765a55a?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 81 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0016b98a8?, 0x3c?, 0xc0016b98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073a0000, 0x2395b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34040, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x7713867cfbde1d25?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xed3606360ea3fd6?, 0x950892d1030ec201?, {0x104d9f28e, 0xf}, 0xe1ba266ad1f866f8?, 0x82adf1129829412b?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 82 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ed8a8?, 0x3c?, 0xc0022ed8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009f20000, 0x2cb43}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde010, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x380be7eba9d091ac?, 0xcdc3aa46c0bc1a35?, {0x104da0b46, 0x11}, 0x6b12e6433aceabf3?, 0xf81e1cdcb849213?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 83 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010658a8?, 0x3c?, 0xc0010658d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f6a000, 0x280f2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34020, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 86 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00170d8a8?, 0x3c?, 0xc00170d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009672000, 0x2b2ad}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0a00, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7bb0255f2edfb115?, 0x53cac2cb6db5f62a?, {0x104d99fcb, 0x8}, 0xdb36e3429029ea37?, 0x3dc429516029a4dc?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 87 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22040, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fb888?, 0x3c?, 0xc0036fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0076a4000, 0x25bd8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228abe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0000, 0xc00035e0c0, {0x104d9c341, 0xb}, 0xc002212d88?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 89 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024117b8?, 0x3c?, 0xc0024117e8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004c38050, 0x4e}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Logf(0xc0004704e0, {0x104dc934d, 0x43}, {0xc003904000, 0x4, 0x4})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:927 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout.func1()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4200 +0x1f8
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4230 +0x8b0
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 91 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36030, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x9fbccad36f9b4a10?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
---
-        sync.runtime_SemacquireMutex(0xc0022158a8?, 0x3c?, 0xc0022158d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c14000, 0x2b9a2}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0be0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x125fdd8098eb4369?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0xbaaedce6af48a03b?, 0xfffffffffffffffe?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 93 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc002369888?, 0x3c?, 0xc0023698b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a448000, 0x2c95f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c000, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xc002215588?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xb5fcaf8e09c2d829?, {0x104d97bc4, 0x6}, 0xa79a754a54f48?, 0x0?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 94 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092010, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69e4a8877fc95dbb?, 0x8c7982fc6da680c9?, {0x104da355c, 0x14}, 0x8500fd1d52e3b9f4?, 0x4354b40d0e1633b2?, 0x1)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0030fd8a8?, 0x3c?, 0xc0030fd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e68000, 0x24cb7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef040, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac000, 0xc00035e0c0, {0x104da0b46, 0x11}, 0xc002274da8?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x25c693849def4b60?, 0x6f8d89639d3002f?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 97 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00174b8a8?, 0x3c?, 0xc00174b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099c2000, 0x2b864}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22080, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x7f743e68d9b3e8d6?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x59a17281194f167c?, 0xff9d942c926a87cd?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 98 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022f18a8?, 0x3c?, 0xc0022f18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009ef2000, 0x2c8f6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34070, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x3d7c84ef6faaaf5a?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x1001123f32cb08f3?, 0xa78c94eaaf04ee0e?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 99 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036f98a8?, 0x3c?, 0xc0036f98d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009096000, 0x22fb8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34060, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xb10a7a7630ea4ece?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f0db, 0xf}, 0xb147804d68657c5b?, 0x988a7e31f5477a8d?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 100 [semacquire]:
-        runtime.Stack({0xc00a3da000, 0x40000, 0x40000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030d1888?, 0x3c?, 0xc0030d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00607c000, 0x2582b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404030, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 105 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a5888?, 0x3c?, 0xc0010a58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006d76000, 0x23abd}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x862745680e0cc971?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xff2c36eb8bff2ba5?, 0xb806244be3ca151?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 106 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34080, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x0?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010a18a8?, 0x3c?, 0xc0010a18d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00703e000, 0x23b36}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde050, 0xc00035e0c0, {0x104da355c, 0x14}, 0x66589097cbbcc65d?, 0x0, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2ab9605cea703901?, 0x809c494dbc5dd38f?, {0x104da355c, 0x14}, 0x7c62561264333017?, 0xae8927080532cb36?, 0x2)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 109 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c34090, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x502f45ae2e2ad83?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9285a759378da374?, 0x428194944008390c?, {0x104d9f28e, 0xf}, 0xce42ae308240497?, 0x50ee4c65d347aded?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0017498a8?, 0x3c?, 0xc0017498d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00980e000, 0x2b64f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde040, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xfe0504872d5cfb42?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0xbade8dc510bc7c11?, 0xb6a1e3794c0b9d31?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 112 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092020, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xd334968715bd13d0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x4a06910294a5b901?, 0x9838068452e8a6bb?, {0x104d98c2c, 0x7}, 0x5bbb861c86aba8d0?, 0xfe7bed3d1b1065c2?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b7888?, 0x3c?, 0xc0016b78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007652000, 0x2345d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408500, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x13a330d559af01e8?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 136 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac020, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x255a408d64403b82?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3ba5f2152c64e901?, 0xeeed46dbde2c8f14?, {0x104d96da6, 0x5}, 0x365a91e8f970f777?, 0x4de481a335dbf36f?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc001709888?, 0x3c?, 0xc0017098b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0094c2000, 0x2b0f8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a2060, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4adced2b930f5cce?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x69548902a22d1d47?, 0xd801810af23e12e0?, {0x104d97bc4, 0x6}, 0xa1a7ffa227688490?, 0xe11221095eb71050?, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 138 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0c0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x3)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023278a8?, 0x3c?, 0xc0023278d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f94000, 0x286ab}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0e0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003924c00?, 0x6?, {0x104da0b46, 0x11}, 0x5?, 0x8?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 141 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c0f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x6?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d97a38, 0x6}, 0x6?, 0xc0035bc2c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016b5888?, 0x3c?, 0xc0016b58b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075a0000, 0x2354a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0024084b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0120, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x70e03040d0e060f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x0?, 0xcb24cb33895569c0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 147 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030a20f0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x363565ccae6e691b?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0b040907070f0a?, 0x10?, {0x104d95eec, 0x3}, 0xa02070d05000309?, 0xf0c0f07040d030d?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174d888?, 0x3c?, 0xc00174d8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009776000, 0x2b576}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c9b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0024040c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x8e951f6124b6418?, 0x0?, {0x104d95edd, 0x3}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 149 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002404060, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x7aa2b4e3362f0d25?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xf7808210c5b76692?, {0x104d96c93, 0x5}, 0x52a9a525f5ef9daf?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7f888?, 0x3c?, 0xc000c7f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006462000, 0x25e94}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0030, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x4c4dd60ab217949f?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 152 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0xa97d2ca27603504?, 0x0, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x741bc0dfd1808701?, 0x471cd7edcad79962?, {0x104da355c, 0x14}, 0x2b35826e5d7d3ccc?, 0xe5bae5cbcc480b58?, 0x4)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00240d8a8?, 0x3c?, 0xc00240d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ef2000, 0x24e23}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092050, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xc1c7130248f10b5e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x2eef834d56ae48e8?, 0x1a3df506e620d160?, {0x104d9f28e, 0xf}, 0x8f9915ffa29ff7c2?, 0x30e985624bb483d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 154 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde070, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf583a2223bab92ad?, 0x1529a93def104a64?, {0x104da0b46, 0x11}, 0xe7f62d0a1ee50744?, 0x2f60d6a50359bc05?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0022178a8?, 0x3c?, 0xc0022178d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009d60000, 0x2bf39}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0d0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x421e77be4308854e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7860265e373c1f6f?, 0x493ec0dd3a894b73?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 156 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00105f8a8?, 0x3c?, 0xc00105f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x277ec}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde080, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xf87fdeff77918975?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1dbf86d16a272f01?, 0x95374b38364ca91c?, {0x104d98c2c, 0x7}, 0x304c5a24d1001a90?, 0x6309c960459b068a?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 157 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c7b8a8?, 0x3c?, 0xc000c7b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066dc000, 0x26db4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0c0, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x8c8b5c25bf948d3c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xd0c8c8c0510568f5?, 0x70baf93a4cf635d3?, {0x104d9f0db, 0xf}, 0x8cab6abac156a263?, 0xe5788d6dded93c68?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 158 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a38a8?, 0x3c?, 0xc0010a38d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0075e8000, 0x29d89}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c7d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e110, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x0?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x2db84e921677241a?, {0x104d99fcb, 0x8}, 0x5cb2c59c537dd73e?, 0x225ef1531c550575?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 159 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010638a8?, 0x3c?, 0xc0010638d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0068be000, 0x27419}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde090, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x12e13e36aa18845f?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x2140fc14f7a26eab?, 0x561d3291087adbe2?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 160 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030fb888?, 0x3c?, 0xc0030fb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0065b8000, 0x26636}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x4a14b545b79064ac?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00271af09?, 0x68?, {0x104d9c341, 0xb}, 0xac1d9a4082ec1601?, 0xdc5efafd7859093e?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 161 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0060, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xfff408c131b09a5c?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3cf8133186859eea?, 0xad7667f5997367f0?, {0x104d95eec, 0x3}, 0x3b054dbf188b5d8a?, 0xcddb3797aaf2933d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0036fd888?, 0x3c?, 0xc0036fd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0070d0000, 0x25638}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef090, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c360c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcdb1b7d63d45a73e?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc8b7699c66a4be64?, 0x5fe4826f102cac83?, {0x104d95edd, 0x3}, 0x6ed8579c301fb92?, 0x66a935f494801e4d?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 179 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cd888?, 0x3c?, 0xc0030cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009072000, 0x232ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a2d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x8e6ff39c88903485?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0xa035da68c033aef0?, 0x7ca13bda90ae6fea?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 180 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092060, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x9585ecc9711dca28?, 0x0, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x4f2f3f28a6b2de9f?, 0xce02eddc299faefa?, 0x5)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735d8a8?, 0x3c?, 0xc00735d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006c6c000, 0x275d5}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a06e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220d0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x43521685a498c61d?, 0x2a0cc28fc1d9bda7?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 184 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022ef8a8?, 0x3c?, 0xc0022ef8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009c6a000, 0x2c16f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e100, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc6eb00f42de7e22e?, 0xcddf09565559966e?, {0x104da0b46, 0x11}, 0x6e292e8658fcd85e?, 0x6c1c5248b38b4baa?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 185 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e0e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xccd28d3c36d35aba?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc00735f8a8?, 0x3c?, 0xc00735f8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074c8000, 0x25bb6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220c0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x5740866fa007b4ec?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x0?, 0x7f3d6af539feb76?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 187 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092080, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0x120fb20d5ff5d2cb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0023218a8?, 0x3c?, 0xc0023218d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00730c000, 0x25d01}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bef0e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220e0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xbee2a46238371b95?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x406010e0e0f020a?, 0x10?, {0x104d99fcb, 0x8}, 0xa6e346d543a3b2b0?, 0x923308d198e8e059?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 189 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0e0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x10a060d09070308?, 0xc0a040308090909?, {0x104d9c53b, 0xb}, 0x80c06070a0b010f?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00170b888?, 0x3c?, 0xc00170b8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b6000, 0x2aa15}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0960, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840c0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x95ecae1e6e75ab76?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xf4b5f1bc147ebfe4?, 0xf3811dc23f118ff3?, {0x104d9c341, 0xb}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 191 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c120, 0xc00035e0c0, {0x104d95eec, 0x3}, 0xffffffffffffffff?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x12ede580cc1725c7?, 0x1?, {0x104d95eec, 0x3}, 0x810409f18c75b092?, 0x7f04e069a87fe68e?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0016bb888?, 0x3c?, 0xc0016bb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a4e4000, 0x2cc7f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308c80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c150, 0xc00035e0c0, {0x104d95edd, 0x3}, 0x0?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x40f070e09060f08?, 0x6020c000f0b0c04?, {0x104d95edd, 0x3}, 0x2010f030809040c?, 0x10?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 193 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015d1888?, 0x3c?, 0xc0015d18b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009a46000, 0x2b6e4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36150, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x5508fcbed3757ecb?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xfffffffefffffc2f?, {0x104d96c93, 0x5}, 0xffffffffffffffff?, 0xc0b29e0e28c8f5ba?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 194 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0036ff8a8?, 0x3c?, 0xc0036ff8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00726c000, 0x259c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092090, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xc41972cb07fd7a20?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x21d76b2930d9004?, {0x104d96da6, 0x5}, 0xd6897c1f2dcc8a6f?, 0xfa28174eb7e8e3fd?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 195 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0xd7348a4707c77254?, 0x0, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x6)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00735b8a8?, 0x3c?, 0xc00735b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007984000, 0x26069}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340f0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0xb72edd8db3de4e38?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x7497b12819946acc?, 0x4902525db8a08b4c?, {0x104d9f28e, 0xf}, 0xd056120cff2cfe31?, 0xba4a9eb7752397b2?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 198 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0015cd8a8?, 0x3c?, 0xc0015cd8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0074ee000, 0x23784}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a08c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177e0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc22931907a939795?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x7e7e8b1b54328318?, 0xc5e8752ff9879673?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 200 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cf8a8?, 0x3c?, 0xc0015cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0071de000, 0x288c6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa0f0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xeda2b1a0147b40ec?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1a70ee8c2d2ca501?, 0x7e8b1b54328318e2?, {0x104d98c2c, 0x7}, 0xc0de3019d9fed974?, 0x3b87fb1a3859f48b?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 201 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005afa110, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xcfe45b55c82a95ae?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x23508afea7a6da42?, 0xad63cb5e43581856?, {0x104d9f0db, 0xf}, 0xe8474a67c12a0205?, 0x36bfd2ab376c4ac0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c818a8?, 0x3c?, 0xc000c818d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0067dc000, 0x2707c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee140, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0d0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0x6e4aecf81243616c?, 0x95498359076ba9dd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 204 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0022840f0, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c341, 0xb}, 0x5aa2fc7d361e9b44?, 0xa959118e4f994273?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00174f888?, 0x3c?, 0xc00174f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0099ee000, 0x2b77a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3ca50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284090, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xbab7898e16025831?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xe7ca31593d07c55?, 0x4b89d956fef84a89?, {0x104d95edd, 0x3}, 0xe77ceafbdafe7e2c?, 0x76276302226a7acd?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 207 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c0c0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0xe1b32eb8f0ce02a?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0023258a8?, 0x3c?, 0xc0023258d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007884000, 0x261eb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b22110, 0xc00035e0c0, {0x104d96da6, 0x5}, 0xeb656753cc4ca418?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3b44ee8d3ad48001?, 0x11b9883ee517e042?, {0x104d96da6, 0x5}, 0xa5db989f41a286ad?, 0x1f03adf29725e2ee?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 209 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc00240f888?, 0x3c?, 0xc00240f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007018000, 0x24dc4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c36120, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x129abde6d06abf9c?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x1d38c6198270fad5?, 0xc41d43b94d53e6b4?, {0x104d97bc4, 0x6}, 0xaa71836246746d08?, 0x3e7ee28a7e42d5e?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 210 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340b0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x9fbba07bbe1f7288?, 0x10197612db6331db?, {0x104da355c, 0x14}, 0x8d22493fd6af10dc?, 0x89622bd92866e1f0?, 0x7)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0010e58a8?, 0x3c?, 0xc0010e58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007062000, 0x23a44}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee280, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340c0, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104da0b46, 0x11}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 213 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b220f0, 0xc00035e0c0, {0x104d97a38, 0x6}, 0x0?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97a38, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c7d8a8?, 0x3c?, 0xc000c7d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f46000, 0x23c79}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be4550, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340e0, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0xa78d34128784b8f9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x91b0507eb27eba1e?, {0x104d98c2c, 0x7}, 0x1c38e2d0483c1ac?, 0x39f6e38bc92f3bfa?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-        
-        goroutine 215 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0015cb8a8?, 0x3c?, 0xc0015cb8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007478000, 0x23874}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e120, 0xc00035e0c0, {0x104d9f0db, 0xf}, 0xc003d9f140?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0xc00278aa00?, {0x104d9f0db, 0xf}, 0xc00278aaa0?, 0x5?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-        
-        goroutine 216 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c340a0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0x5?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc003e3aba0?, 0x6?, {0x104d99fcb, 0x8}, 0x5?, 0x9?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc0005038a8?, 0x3c?, 0xc0005038d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006628000, 0x2675c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228a320, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004092070, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x9?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c53b, 0xb}, 0x9?, 0xc003ea77a0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-        
-        goroutine 218 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0022eb888?, 0x3c?, 0xc0022eb8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc009e84000, 0x2c58d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230c060, 0xc00035e0c0, {0x104d9c341, 0xb}, 0x8?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x6?, 0x6?, {0x104d9c341, 0xb}, 0x9?, 0xc0028aa9b0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-        
-        goroutine 219 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xc0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00c0, 0xc00035e0c0, {0x104d95eec, 0x3}, 0x4f7298dc3840b24a?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0040cd888?, 0x3c?, 0xc0040cd8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ea6000, 0x24b48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023097c0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00409c0c0, 0xc00035e0c0, {0x104d95edd, 0x3}, 0xcc81588eb854483e?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xc00277af09?, 0x68?, {0x104d95edd, 0x3}, 0x58e631a1b9b05e01?, 0x7e1e6e610a96154c?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-        
-        goroutine 221 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be0090, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x501b50423d8c4a38?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x417ec613f4a83f68?, 0x17142025401f8635?, {0x104d96c93, 0x5}, 0xd5d22bb6d2a73c74?, 0xa110e1d9894c8b32?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc000c4f888?, 0x3c?, 0xc000c4f8b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005f90000, 0x253ed}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c5f0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be00f0, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x76d1800eeb4aa491?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 224 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4b8a8?, 0x3c?, 0xc000c4b8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0062a6000, 0x25d46}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308aa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177d0, 0xc00035e0c0, {0x104da355c, 0x14}, 0x490625455cb727a3?, 0x0, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x25a4886cc69d6501?, 0xfc5b11d5f25087a8?, {0x104da355c, 0x14}, 0xa3c70a08de68c6fe?, 0xbbc2e1c45c28a000?, 0x8)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-        
-        goroutine 225 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0040c78a8?, 0x3c?, 0xc0040c78d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004584000, 0x233ee}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e000, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0019177c0, 0xc00035e0c0, {0x104d9f28e, 0xf}, 0x2d10ac9209b6e2d9?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x35bc3877184591db?, 0x5f9bde25f2b0f5eb?, {0x104d9f28e, 0xf}, 0x612d8f587344b56b?, 0x118cd3f700a03404?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-        
-        goroutine 226 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c518a8?, 0x3c?, 0xc000c518d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006650000, 0x2333b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3c690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e140, 0xc00035e0c0, {0x104da0b46, 0x11}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x3913ead7fc6cad85?, 0xd5991ddb3aad1800?, {0x104da0b46, 0x11}, 0x49edc15027d6eed0?, 0x829592d78b546cc1?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-        
-        goroutine 227 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010618a8?, 0x3c?, 0xc0010618d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe8000, 0x23b20}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee230, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000e7e130, 0xc00035e0c0, {0x104d97a38, 0x6}, 0xc235486b92bc4a6a?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x892753b0aad431b7?, 0xdbcc5daf59720d24?, {0x104d97a38, 0x6}, 0x963088d3a75e8a8e?, 0xf72b6c2be33b62b8?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-        
-        goroutine 228 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00407c110, 0xc00035e0c0, {0x104d98c2c, 0x7}, 0x4040e0b0e000c0c?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d98c2c, 0x7}, 0x13369cdc0d051daa?, 0x93b5fb8dadd8c7ff?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc00236d8a8?, 0x3c?, 0xc00236d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00a2fe000, 0x2ca48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d20, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920b0, 0xc00035e0c0, {0x104d99fcb, 0x8}, 0xd9ef7b878653e461?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0xa11e51b290932fa6?, {0x104d99fcb, 0x8}, 0xffffffffffffffff?, 0x8f3786b9cbf88339?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-        
-        goroutine 231 [semacquire]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040920a0, 0xc00035e0c0, {0x104d9c53b, 0xb}, 0x7ca7c9b262da82ed?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9c53b, 0xb}, 0xc31fc9fcff0b79c9?, 0xdec3e9390759a97d?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
---
-        sync.runtime_SemacquireMutex(0xc007359888?, 0x3c?, 0xc0073598b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ea4000, 0x256a3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32190, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1da0, 0xc00035e0c0, {0x104d96c93, 0x5}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0xce7b2a6985d5b02e?, 0xb1711adf781125d1?, {0x104d96c93, 0x5}, 0x0?, 0x0?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-        
-        goroutine 236 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc000c4d8a8?, 0x3c?, 0xc000c4d8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006338000, 0x25baa}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a05a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000bde0c0, 0xc00035e0c0, {0x104d96da6, 0x5}, 0x26558a93ce71eb8e?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d96da6, 0x5}, 0x636004e917549a67?, 0x25887175afbd8db3?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-        
-        goroutine 237 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0010a7888?, 0x3c?, 0xc0010a78b8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007430000, 0x2362c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408050, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0021b1d70, 0xc00035e0c0, {0x104d97bc4, 0x6}, 0x9f93070fbcfd80ae?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x83faf30ef87fd675?, 0x6674a085ddfef721?, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4190 +0x164
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-        
-        goroutine 238 [semacquire]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0x1?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030ac100, 0xc00035e0c0, {0x104da355c, 0x14}, 0x0?, 0x0, 0x9)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007754000, 0x13996}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003920180, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007754000, 0x13996}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ac80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003920180, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007f7e000, 0x13a08}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3caf0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228ad20, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003905a80, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006346000, 0x142a8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0780, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002284b70, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        time.Time.AppendFormat({0x15d3813b6?, 0xc00037e900?, 0x1055c42e0?}, {0xc0030cfa58, 0x0, 0x40}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:630 +0x1c0
-        time.Time.Format({0xc0030cfaf8?, 0x104d40fcc?, 0x1055c42e0?}, {0x104d9cd74, 0xc})
-        	/Users/jekamas/go/go1.19.2/src/time/format.go:608 +0xa8
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:8 +0x34
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x13f4c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0af0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228b9f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006bba000, 0x1469f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5720, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003984c40, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 67 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006b1c000, 0x13f4c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0af0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228b9f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:81 +0x7c
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006eb6000, 0x14095}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a13b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be57c0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fe0000, 0x1423a}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a1400, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039c8cc0, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00738e000, 0x14122}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222edc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1450, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00738e000, 0x14122}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222edc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1450, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 1 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:81 +0x7c
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007856000, 0x13fa8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bfed80, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000be5b80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5b80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1cc0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
---
-        sync.poolRaceAddr(...)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:89
-        sync.(*Pool).Put(0x1a?, {0x1050d3be0, 0xc001085790})
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:104 +0x64
-        fmt.(*pp).free(0xc001085790)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:161 +0x130
-        fmt.Fprintf({0x1050f5f60, 0xc0046977a0}, {0x104d98aab, 0x7}, {0xc0016c38f8, 0x2, 0x2})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:206 +0xac
-        testing.(*common).decorate(0xc0004704e0?, {0xc007856000, 0x13fa8}, 0xc007856000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:671 +0x1e8
-        testing.(*common).logDepth(0xc0004704e0, {0xc007856000, 0x13fa8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ef50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bfed80, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00788a000, 0x14093}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5b80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a1cc0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32640, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007c7c000, 0x14295}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003965a80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive, 2 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007c7c000, 0x14295}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003965a80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive, 2 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007c7c000, 0x14295}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee1e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003965a80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive, 2 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0081ac000, 0x142ea}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222f810, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b1e1c0, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32910, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008182000, 0x13f54}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee730, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f400, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 2 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008894000, 0x1401f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f860, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 2 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008894000, 0x1401f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f860, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 2 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005e2c000, 0x1408f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030b01e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b1ea80, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005e2c000, 0x1408f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030b01e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376a440, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005e2c000, 0x1408f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0030b01e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc005e62000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006256000, 0x13fa8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222eff0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [runnable]:
-        strings.(*Builder).WriteString(0xc0046772a0, {0xc00622c9d6, 0x27})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc00622a000, 0x1423e}, 0xc00622a000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006636000, 0x13e4b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33c70, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee870, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006636000, 0x13e4b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33c70, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee870, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006aa2000, 0x13ebb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308a50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230d530, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        github.com/ethereum/go-ethereum/common.NowMilliseconds()
-        	/Users/jekamas/projects/bor/common/time.go:7 +0x5c
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f0e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x508
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006aa2000, 0x13ebb}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308a50, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00230d530, 0xc00035e0c0, {0x104d99e8b, 0x8}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3890 +0x398
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002308af0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002308af0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f0e0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006f00000, 0x14110}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002309130, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944100, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 67 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006eae000, 0x14094}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0023090e0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002409ea0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007346000, 0x14018}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002309270, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222fa90, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc000f88c70, {0xc007310000, 0x14275})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b8000, 0x14539}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b180, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228aaf0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077b8000, 0x14539}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b180, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228aaf0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007c76000, 0x14037}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b270, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003984600, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        strings.(*Builder).WriteString(0xc004682860, {0xc007bdc295, 0x3d})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x100
-        testing.(*common).decorate(0xc0004704e0?, {0xc007bd6000, 0x13dd4}, 0xc007bd6000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007bd6000, 0x13dd4}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007cf8000, 0x14125}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002309b80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bef950, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 3 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004564000, 0x13dd3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d70, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a52000, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0045a4000, 0x1430f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0e10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c820, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039c8700, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004564000, 0x13dd3}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0d70, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a52000, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [semacquire]:
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0045a4000, 0x1430f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0e10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c820, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a52080, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005dd2000, 0x13e48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a53140, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc00143d080, {0x1051f2553, 0xf})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
-        fmt.(*fmt).fmtS(0xc00143d080, {0x1051f2553, 0xf})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:359 +0x7c
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005dd2000, 0x13e48}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228ab40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a53140, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        strings.Index({0xc005dc3311, 0xeac3}, {0x104f92078, 0x1})
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
-        strings.genSplit({0xc005dbe000, 0x13dd4}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
-        strings.Split(...)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005e82000, 0x1413f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cdc0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003920d00, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive, 4 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0024138a8?, 0x3c?, 0xc0024138d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006694000, 0x13e4c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b325a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003a0ed80, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-        
-        goroutine 67 [chan receive, 4 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006aba000, 0x14095}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b180, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3d860, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b1e780, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006eee000, 0x140b0}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408690, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003921680, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [runnable]:
-        fmt.(*buffer).writeString(...)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:82
-        fmt.(*fmt).padString(0xc000e5b150, {0xc006f04000, 0x14262})
-        	/Users/jekamas/go/go1.19.2/src/fmt/format.go:110 +0xc8
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007374000, 0x143ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376af40, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [semacquire]:
-        runtime.Stack({0xc007338000, 0x10000, 0x10000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007374000, 0x143ef}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408870, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376af40, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 67 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007348000, 0x14021}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408820, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b33090, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00783a000, 0x14016}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00228b900, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00228b770, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc002408b90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408b90, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00828c000, 0x1430b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222eaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039a6d00, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [runnable]:
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:48 +0x58
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039ea540, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4ec
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008258000, 0x13fca}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002408e10, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00828c000, 0x1430b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222eaa0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0039a6d00, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 67 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc008258000, 0x13fca}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be44b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002408e10, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004608000, 0x13e63}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003090040, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 67 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d9f28e, 0xf}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
---
-        sync.runtime_SemacquireMutex(0xc0037c58a8?, 0x3c?, 0xc0037c58d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004608000, 0x13e63}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee0a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003090040, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
-        github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-        
-        goroutine 66 [runnable]:
-        time.(*Location).lookup(0x1055c42e0, 0x6368ec9b)
-        	/Users/jekamas/go/go1.19.2/src/time/zoneinfo.go:124 +0x5c4
-        time.Time.locabs({0xc0d25906d927b280, 0x5677155c75, 0x1055c42e0})
-        	/Users/jekamas/go/go1.19.2/src/time/time.go:472 +0x178
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc004bd8000, 0x13dd9}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222e4b0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002408000, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 5 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ed6000, 0x13f2f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee5a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944580, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        strings.Index({0xc005ea1f62, 0xe0b7}, {0x104f92078, 0x1})
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
-        strings.genSplit({0xc005e9c000, 0x14019}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
-        strings.Split(...)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005ed6000, 0x13f2f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004bee5a0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003944580, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        strings.Index({0xc005eae13e, 0x1edb}, {0x104f92078, 0x1})
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
-        strings.genSplit({0xc005e9c000, 0x14019}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
-        strings.Split(...)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006fd4000, 0x13fa6}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004befb30, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a11d0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000034e10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000034e10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00700e000, 0x14396}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000be5180, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222f8b0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 6 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00742c000, 0x14018}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376a180, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        strings.Index({0xc0073ef208, 0x4e87}, {0x104f92078, 0x1})
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:1103 +0x5f4
-        strings.genSplit({0xc0073e0000, 0x1408f}, {0x104f92078, 0x1}, 0x0, 0xffffffffffffffff)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:254 +0x14c
-        strings.Split(...)
-        	/Users/jekamas/go/go1.19.2/src/strings/strings.go:308
---
-        sync.runtime_SemacquireMutex(0xc0016c3938?, 0x3c?, 0xc0016c3968?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00742c000, 0x14018}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222fef0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00376a180, 0xc00035e0c0, {0x104d9ac6f, 0x9}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3880 +0x354
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-        
-        goroutine 63 [runnable]:
-        strings.(*Builder).WriteString(0xc004682300, {0x104d9af36, 0x9})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
-        testing.(*common).decorate(0xc0004704e0?, {0xc0073e0000, 0x1408f}, 0xc0073e0000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:679 +0x324
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073e0000, 0x1408f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007cc0000, 0x13e13}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be5c20, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007cc0000, 0x13e13}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be5c20, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007cc0000, 0x13e13}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3cc80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc000be5c20, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00459c000, 0x1401d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c5f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00459c000, 0x1401d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002408b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3c5f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc005e62000, 0x1401c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e10, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004c3cc30, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:220 +0x7c
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b32e60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006228000, 0x1401f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006228000, 0x1401f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006228000, 0x1401f}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33310, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b32eb0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 7 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066bc000, 0x1423c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002409b80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308cd0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0066bc000, 0x1423c}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc002409b80, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002308cd0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.(*Pool).pin(0x1055aa560)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:198 +0xcc
-        sync.(*Pool).Put(0x1055aa560?, {0x1050d3be0, 0xc0019a7860})
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:107 +0xa0
-        fmt.(*pp).free(0xc0019a7860)
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:161 +0x130
-        fmt.Fprintf({0x1050f5f60, 0xc004683600}, {0x104d98aab, 0x7}, {0xc0010e98d8, 0x2, 0x2})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:206 +0xac
-        testing.(*common).decorate(0xc0004704e0?, {0xc006a12000, 0x14092}, 0xc006a12000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:671 +0x1e8
-        testing.(*common).logDepth(0xc0004704e0, {0xc006a12000, 0x14092}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:902 +0x144
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc004c3df40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc005b33540, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ac4000, 0x1411d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b336d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002409c20, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003905080, 0xc00035e0c0, {0x104d9d9a0, 0xd}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000788000, 0x2710, 0xc0005b8ed8?}, 0xc00407c000, 0xc0005b8f38?, 0x1043c85d0?, 0x1055c4b1c?, {0x104d9d9a0, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006ac4000, 0x1411d}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b336d0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002409c20, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [runnable]:
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc003905040, 0xc00035e0c0, {0x104d9ac78, 0x9}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4222 +0x4fc
-        github.com/ethereum/go-ethereum/core.addTransactions({0x1050ffee0, 0xc0004704e0}, {0xc000518000, 0x2710, 0x0?}, 0xc005b22000, 0x0?, 0x0?, 0x0?, {0x104d9ac78, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4145 +0x250
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e7c000, 0x13e4b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33db0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309590, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e7c000, 0x13e4b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33db0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309590, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc006e7c000, 0x13e4b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc005b33db0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309590, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0030cf8a8?, 0x3c?, 0xc0030cf8d8?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0073aa000, 0x142b8}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ebe0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc0040a0cd0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 66 [runnable]:
-        strings.(*Builder).WriteString(0xc004676060, {0xc0072b17ee, 0x3b})
-        	/Users/jekamas/go/go1.19.2/src/strings/builder.go:124 +0x144
-        testing.(*common).decorate(0xc0004704e0?, {0xc0072ae000, 0x13e4a}, 0xc0072ae000?)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:681 +0x33c
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc007396000, 0x13e4b}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc0040a0eb0, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc00222e0f0, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077d8000, 0x14093}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ee60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309d60, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc0077d8000, 0x14093}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc00222ee60, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc002309d60, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 8 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.poolRaceAddr(...)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:89
-        sync.(*Pool).Get(0x1055aa560)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:147 +0xdc
-        fmt.newPrinter()
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:137 +0x2c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000034b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:218 +0x38
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000034b40, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004bee4b0, 0xc00035e0c0, {0x104d9b866, 0xa}, 0x106545ac0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc000554000, 0x2710, 0x0?}, 0xc000e7e010, 0x0?, 0x0?, 0x0?, {0x104d9b866, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        github.com/ethereum/go-ethereum/core.apiWithMining.func3()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3910 +0x144
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3907 +0xf04
-        
-        goroutine 64 [semacquire]:
-        runtime.Stack({0xc007c74000, 0x20000, 0x20000}, 0x1)
-        	/Users/jekamas/go/go1.19.2/src/runtime/mprof.go:1195 +0x40
-        github.com/ethereum/go-ethereum/common/debug.Stack(0xe0?)
-        	/Users/jekamas/projects/bor/common/debug/debug.go:44 +0x70
---
-        sync.(*Pool).pin(0x1055aa560)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:198 +0xcc
-        sync.(*Pool).Get(0x1055aa560)
-        	/Users/jekamas/go/go1.19.2/src/sync/pool.go:131 +0x34
-        fmt.newPrinter()
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:137 +0x2c
-        fmt.Sprintf({0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/fmt/print.go:218 +0x38
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x70
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 9 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00890e000, 0x13dd7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 9 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00890e000, 0x13dd7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 9 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
---
-        sync.runtime_SemacquireMutex(0xc0010e9918?, 0x3c?, 0xc0010e9948?)
-        	/Users/jekamas/go/go1.19.2/src/runtime/sema.go:77 +0x24
-        sync.(*Mutex).lockSlow(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:171 +0x1f8
-        sync.(*Mutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/mutex.go:90 +0x60
-        sync.(*RWMutex).Lock(0xc0004704e0)
-        	/Users/jekamas/go/go1.19.2/src/sync/rwmutex.go:147 +0x3c
-        testing.(*common).logDepth(0xc0004704e0, {0xc00890e000, 0x13dd7}, 0x3)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:881 +0x44
-        testing.(*common).log(...)
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:876
-        testing.(*common).Errorf(0xc0004704e0, {0x104dc39f9, 0x34}, {0xc000035720, 0x5, 0x5})
-        	/Users/jekamas/go/go1.19.2/src/testing/testing.go:940 +0x84
-        github.com/ethereum/go-ethereum/core.runWithTimeout({0x1050ffee0, 0xc0004704e0}, 0xc004beef50, 0xc00035e0c0, {0x104d9e448, 0xe}, 0x0?, 0x0, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4223 +0x704
-        github.com/ethereum/go-ethereum/core.addTransactionsBatches({0x1050ffee0, 0xc0004704e0}, {0xc0007c4000, 0x2710, 0x0?}, 0xc004bec010, 0x0?, 0x0?, 0x0?, {0x104d9e448, ...}, ...)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4124 +0x370
-        created by github.com/ethereum/go-ethereum/core.apiWithMining.func5
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:3927 +0x270
-        
-        goroutine 79 [chan receive, 9 minutes]:
-        github.com/ethereum/go-ethereum/core.runWithTicker({0x1050ffee0, 0xc0004704e0}, 0x0?, 0x0?, {0x104d97bc4, 0x6}, 0x0?, 0x0?, 0x0)
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-        github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-        created by github.com/ethereum/go-ethereum/core.apiWithMining
-        	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
diff --git a/test1.txt b/test1.txt
deleted file mode 100644
index 1de0dab433..0000000000
--- a/test1.txt
+++ /dev/null
@@ -1,5602 +0,0 @@
-GODEBUG=cgocheck=0 go test -buildvcs=false -ldflags "-X github.com/ethereum/go-ethereum/params.GitCommit=8de32f470c226fe4186211090e49338955205d80 -X github.com/ethereum/go-ethereum/params.GitBranch=shivam/txpool-tracing-optimizations -X github.com/ethereum/go-ethereum/params.GitTag=v0.2.17" -p 1 -run=TestPoolMiningDataRaces --timeout 10m -race -v ./core/
-=== RUN   TestPoolMiningDataRaces
-=== RUN   TestPoolMiningDataRaces/size_1
-    tx_pool_test.go:3866: [12:07:01.110] starting goroutines
-    tx_pool_test.go:4116: [12:07:01.110] starting AddRemotes
-    tx_pool_test.go:4116: [12:07:01.110] starting AddRemotesSync
-    tx_pool_test.go:3873: [12:07:01.110] starting AddLocal(s)
-    tx_pool_test.go:4136: [12:07:01.110] starting AddRemoteSync
-    tx_pool_test.go:4091: [12:07:01.111] before the first propagated transaction
-    tx_pool_test.go:4093: [12:07:01.111] after the first propagated transaction
-    tx_pool_test.go:4136: [12:07:01.110] starting AddRemote
-    tx_pool_test.go:3722: [12:07:02.115] mining block. block 0. total 400: pending 18(added 0), local 1(added 400), queued 56
-    tx_pool_test.go:3722: [12:07:03.114] mining block. block 1. total 400: pending 4(added 400), local 0(added 0), queued 140
-    tx_pool_test.go:3722: [12:07:04.116] mining block. block 2. total 400: pending 3(added 400), local 0(added 0), queued 205
-    tx_pool_test.go:3722: [12:07:05.116] mining block. block 3. total 400: pending 2(added 400), local 0(added 0), queued 276
-    tx_pool_test.go:3722: [12:07:06.114] mining block. block 4. total 400: pending 1(added 400), local 0(added 0), queued 348
-    tx_pool_test.go:3722: [12:07:07.115] mining block. block 5. total 0: pending 0(added 0), local 0(added 0), queued 415
-    tx_pool_test.go:3722: [12:07:08.113] mining block. block 6. total 0: pending 0(added 0), local 0(added 0), queued 483
-    tx_pool_test.go:3722: [12:07:09.113] mining block. block 7. total 0: pending 0(added 0), local 0(added 0), queued 552
-    tx_pool_test.go:3722: [12:07:10.113] mining block. block 8. total 0: pending 0(added 0), local 0(added 0), queued 620
-    tx_pool_test.go:3722: [12:07:11.113] mining block. block 9. total 0: pending 0(added 0), local 0(added 0), queued 689
-    tx_pool_test.go:3722: [12:07:12.113] mining block. block 10. total 0: pending 0(added 0), local 0(added 0), queued 758
-    tx_pool_test.go:3722: [12:07:13.113] mining block. block 11. total 0: pending 0(added 0), local 0(added 0), queued 829
-    tx_pool_test.go:3722: [12:07:14.113] mining block. block 12. total 0: pending 0(added 0), local 0(added 0), queued 900
-    tx_pool_test.go:3722: [12:07:15.114] mining block. block 13. total 0: pending 0(added 0), local 0(added 0), queued 968
-    tx_pool_test.go:3722: [12:07:16.114] mining block. block 14. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:17.113] mining block. block 15. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:18.115] mining block. block 16. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:19.114] mining block. block 17. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:20.116] mining block. block 18. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:21.114] mining block. block 19. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:22.118] mining block. block 20. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:23.112] mining block. block 21. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:24.116] mining block. block 22. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:25.114] mining block. block 23. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:26.114] mining block. block 24. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:27.118] mining block. block 25. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:28.114] mining block. block 26. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:29.113] mining block. block 27. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:30.114] mining block. block 28. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:31.114] mining block. block 29. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:32.114] mining block. block 30. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:33.114] mining block. block 31. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:34.117] mining block. block 32. total 0: pending 0(added 0), local 0(added 0), queued 1025
-    tx_pool_test.go:3722: [12:07:35.112] mining block. block 33. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:36.113] mining block. block 34. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:37.112] mining block. block 35. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:38.113] mining block. block 36. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:39.113] mining block. block 37. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:40.112] mining block. block 38. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:41.112] mining block. block 39. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:42.112] mining block. block 40. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:43.112] mining block. block 41. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:44.112] mining block. block 42. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:45.115] mining block. block 43. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:46.112] mining block. block 44. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:47.114] mining block. block 45. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:48.113] mining block. block 46. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:49.113] mining block. block 47. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:50.115] mining block. block 48. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:51.112] mining block. block 49. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:52.113] mining block. block 50. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:53.113] mining block. block 51. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:54.113] mining block. block 52. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:55.112] mining block. block 53. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:56.113] mining block. block 54. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:57.112] mining block. block 55. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:58.113] mining block. block 56. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:07:59.113] mining block. block 57. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:00.112] mining block. block 58. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:01.113] mining block. block 59. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:02.112] mining block. block 60. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:03.112] mining block. block 61. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:04.112] mining block. block 62. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:05.112] mining block. block 63. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:06.113] mining block. block 64. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:07.112] mining block. block 65. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:08.112] mining block. block 66. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:09.113] mining block. block 67. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:10.113] mining block. block 68. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:11.113] mining block. block 69. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:12.112] mining block. block 70. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:13.112] mining block. block 71. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:14.113] mining block. block 72. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:15.113] mining block. block 73. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:16.112] mining block. block 74. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:17.113] mining block. block 75. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:18.112] mining block. block 76. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:19.112] mining block. block 77. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:20.112] mining block. block 78. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:21.112] mining block. block 79. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:22.112] mining block. block 80. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:23.111] mining block. block 81. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:24.112] mining block. block 82. total 0: pending 0(added 0), local 0(added 0), queued 1024
-    tx_pool_test.go:3722: [12:08:25.112] mining block. block 83. total 0: pending 0(added 0), local 0(added 0), queued 1035
-    tx_pool_test.go:3722: [12:08:26.112] mining block. block 84. total 0: pending 0(added 0), local 0(added 0), queued 1050
-    tx_pool_test.go:3722: [12:08:27.112] mining block. block 85. total 0: pending 0(added 0), local 0(added 0), queued 1063
-    tx_pool_test.go:3722: [12:08:28.112] mining block. block 86. total 0: pending 0(added 0), local 0(added 0), queued 1075
-    tx_pool_test.go:3722: [12:08:29.112] mining block. block 87. total 0: pending 0(added 0), local 0(added 0), queued 1087
-    tx_pool_test.go:3722: [12:08:30.112] mining block. block 88. total 0: pending 0(added 0), local 0(added 0), queued 1099
-    tx_pool_test.go:3722: [12:08:31.112] mining block. block 89. total 0: pending 0(added 0), local 0(added 0), queued 1113
-    tx_pool_test.go:3722: [12:08:32.112] mining block. block 90. total 0: pending 0(added 0), local 0(added 0), queued 1128
-    tx_pool_test.go:3722: [12:08:33.112] mining block. block 91. total 0: pending 0(added 0), local 0(added 0), queued 1140
-    tx_pool_test.go:3722: [12:08:34.112] mining block. block 92. total 0: pending 0(added 0), local 0(added 0), queued 1153
-    tx_pool_test.go:3722: [12:08:35.112] mining block. block 93. total 0: pending 0(added 0), local 0(added 0), queued 1166
-    tx_pool_test.go:3722: [12:08:36.111] mining block. block 94. total 0: pending 0(added 0), local 0(added 0), queued 1179
-    tx_pool_test.go:3722: [12:08:37.112] mining block. block 95. total 0: pending 0(added 0), local 0(added 0), queued 1191
-    tx_pool_test.go:3722: [12:08:38.112] mining block. block 96. total 0: pending 0(added 0), local 0(added 0), queued 1204
-    tx_pool_test.go:3722: [12:08:39.112] mining block. block 97. total 0: pending 0(added 0), local 0(added 0), queued 1217
-    tx_pool_test.go:3722: [12:08:40.111] mining block. block 98. total 0: pending 0(added 0), local 0(added 0), queued 1228
-    tx_pool_test.go:3722: [12:08:41.111] mining block. block 99. total 0: pending 0(added 0), local 0(added 0), queued 1239
-    tx_pool_test.go:3722: [12:08:42.112] mining block. block 100. total 0: pending 0(added 0), local 0(added 0), queued 1252
-    tx_pool_test.go:3722: [12:08:43.112] mining block. block 101. total 0: pending 0(added 0), local 0(added 0), queued 1266
-    tx_pool_test.go:3722: [12:08:44.112] mining block. block 102. total 0: pending 0(added 0), local 0(added 0), queued 1280
-    tx_pool_test.go:3722: [12:08:45.113] mining block. block 103. total 0: pending 0(added 0), local 0(added 0), queued 1293
-    tx_pool_test.go:3722: [12:08:46.113] mining block. block 104. total 0: pending 0(added 0), local 0(added 0), queued 1306
-    tx_pool_test.go:3722: [12:08:47.111] mining block. block 105. total 0: pending 0(added 0), local 0(added 0), queued 1322
-    tx_pool_test.go:3722: [12:08:48.112] mining block. block 106. total 0: pending 0(added 0), local 0(added 0), queued 1336
-    tx_pool_test.go:3722: [12:08:49.112] mining block. block 107. total 0: pending 0(added 0), local 0(added 0), queued 1349
-    tx_pool_test.go:3722: [12:08:50.112] mining block. block 108. total 0: pending 0(added 0), local 0(added 0), queued 1363
-    tx_pool_test.go:3722: [12:08:51.112] mining block. block 109. total 0: pending 0(added 0), local 0(added 0), queued 1377
-    tx_pool_test.go:3722: [12:08:52.112] mining block. block 110. total 0: pending 0(added 0), local 0(added 0), queued 1390
-    tx_pool_test.go:3722: [12:08:53.112] mining block. block 111. total 0: pending 0(added 0), local 0(added 0), queued 1404
-    tx_pool_test.go:3722: [12:08:54.112] mining block. block 112. total 0: pending 0(added 0), local 0(added 0), queued 1417
-    tx_pool_test.go:3722: [12:08:55.112] mining block. block 113. total 0: pending 0(added 0), local 0(added 0), queued 1430
-    tx_pool_test.go:3722: [12:08:56.112] mining block. block 114. total 0: pending 0(added 0), local 0(added 0), queued 1443
-    tx_pool_test.go:3722: [12:08:57.112] mining block. block 115. total 0: pending 0(added 0), local 0(added 0), queued 1455
-    tx_pool_test.go:3722: [12:08:58.112] mining block. block 116. total 0: pending 0(added 0), local 0(added 0), queued 1468
-    tx_pool_test.go:3722: [12:08:59.112] mining block. block 117. total 0: pending 0(added 0), local 0(added 0), queued 1481
-    tx_pool_test.go:3722: [12:09:00.112] mining block. block 118. total 0: pending 0(added 0), local 0(added 0), queued 1495
-    tx_pool_test.go:3722: [12:09:01.112] mining block. block 119. total 0: pending 0(added 0), local 0(added 0), queued 1508
-    tx_pool_test.go:3722: [12:09:02.112] mining block. block 120. total 0: pending 0(added 0), local 0(added 0), queued 1522
-    tx_pool_test.go:3722: [12:09:03.112] mining block. block 121. total 0: pending 0(added 0), local 0(added 0), queued 1533
-    tx_pool_test.go:3722: [12:09:04.112] mining block. block 122. total 0: pending 0(added 0), local 0(added 0), queued 1546
-    tx_pool_test.go:3722: [12:09:05.112] mining block. block 123. total 0: pending 0(added 0), local 0(added 0), queued 1558
-    tx_pool_test.go:3722: [12:09:06.112] mining block. block 124. total 0: pending 0(added 0), local 0(added 0), queued 1569
-    tx_pool_test.go:3722: [12:09:07.111] mining block. block 125. total 0: pending 0(added 0), local 0(added 0), queued 1584
-    tx_pool_test.go:3722: [12:09:08.112] mining block. block 126. total 0: pending 0(added 0), local 0(added 0), queued 1596
-    tx_pool_test.go:3722: [12:09:09.112] mining block. block 127. total 0: pending 0(added 0), local 0(added 0), queued 1608
-    tx_pool_test.go:3722: [12:09:10.112] mining block. block 128. total 0: pending 0(added 0), local 0(added 0), queued 1623
-    tx_pool_test.go:3722: [12:09:11.112] mining block. block 129. total 0: pending 0(added 0), local 0(added 0), queued 1636
-    tx_pool_test.go:3722: [12:09:12.112] mining block. block 130. total 0: pending 0(added 0), local 0(added 0), queued 1649
-    tx_pool_test.go:3722: [12:09:13.111] mining block. block 131. total 0: pending 0(added 0), local 0(added 0), queued 1663
-    tx_pool_test.go:3722: [12:09:14.111] mining block. block 132. total 0: pending 0(added 0), local 0(added 0), queued 1675
-    tx_pool_test.go:3722: [12:09:15.112] mining block. block 133. total 0: pending 0(added 0), local 0(added 0), queued 1688
-    tx_pool_test.go:3722: [12:09:16.113] mining block. block 134. total 0: pending 0(added 0), local 0(added 0), queued 1701
-    tx_pool_test.go:3722: [12:09:17.112] mining block. block 135. total 0: pending 0(added 0), local 0(added 0), queued 1713
-    tx_pool_test.go:3722: [12:09:18.112] mining block. block 136. total 0: pending 0(added 0), local 0(added 0), queued 1726
-    tx_pool_test.go:3722: [12:09:19.112] mining block. block 137. total 0: pending 0(added 0), local 0(added 0), queued 1741
-    tx_pool_test.go:3722: [12:09:20.111] mining block. block 138. total 0: pending 0(added 0), local 0(added 0), queued 1752
-    tx_pool_test.go:3722: [12:09:21.111] mining block. block 139. total 0: pending 0(added 0), local 0(added 0), queued 1764
-    tx_pool_test.go:3722: [12:09:22.111] mining block. block 140. total 0: pending 0(added 0), local 0(added 0), queued 1777
-    tx_pool_test.go:3722: [12:09:23.111] mining block. block 141. total 0: pending 0(added 0), local 0(added 0), queued 1791
-    tx_pool_test.go:3722: [12:09:24.112] mining block. block 142. total 0: pending 0(added 0), local 0(added 0), queued 1803
-    tx_pool_test.go:3722: [12:09:25.112] mining block. block 143. total 0: pending 0(added 0), local 0(added 0), queued 1819
-    tx_pool_test.go:3722: [12:09:26.112] mining block. block 144. total 0: pending 0(added 0), local 0(added 0), queued 1834
-    tx_pool_test.go:3722: [12:09:27.111] mining block. block 145. total 0: pending 0(added 0), local 0(added 0), queued 1847
-    tx_pool_test.go:3722: [12:09:28.112] mining block. block 146. total 0: pending 0(added 0), local 0(added 0), queued 1860
-    tx_pool_test.go:3722: [12:09:29.111] mining block. block 147. total 0: pending 0(added 0), local 0(added 0), queued 1873
-    tx_pool_test.go:3722: [12:09:30.112] mining block. block 148. total 0: pending 0(added 0), local 0(added 0), queued 1887
-    tx_pool_test.go:3722: [12:09:31.112] mining block. block 149. total 0: pending 0(added 0), local 0(added 0), queued 1899
-    tx_pool_test.go:3722: [12:09:32.111] mining block. block 150. total 0: pending 0(added 0), local 0(added 0), queued 1912
-    tx_pool_test.go:3722: [12:09:33.112] mining block. block 151. total 0: pending 0(added 0), local 0(added 0), queued 1923
-    tx_pool_test.go:3722: [12:09:34.112] mining block. block 152. total 0: pending 0(added 0), local 0(added 0), queued 1936
-    tx_pool_test.go:3722: [12:09:35.112] mining block. block 153. total 0: pending 0(added 0), local 0(added 0), queued 1950
-    tx_pool_test.go:3722: [12:09:36.112] mining block. block 154. total 0: pending 0(added 0), local 0(added 0), queued 1962
-    tx_pool_test.go:3722: [12:09:37.112] mining block. block 155. total 0: pending 0(added 0), local 0(added 0), queued 1974
-    tx_pool_test.go:3722: [12:09:38.112] mining block. block 156. total 0: pending 0(added 0), local 0(added 0), queued 1984
-    tx_pool_test.go:3722: [12:09:39.112] mining block. block 157. total 0: pending 0(added 0), local 0(added 0), queued 1998
-    tx_pool_test.go:3722: [12:09:40.112] mining block. block 158. total 0: pending 0(added 0), local 0(added 0), queued 2012
-    tx_pool_test.go:3722: [12:09:41.112] mining block. block 159. total 0: pending 0(added 0), local 0(added 0), queued 2027
-    tx_pool_test.go:3722: [12:09:42.112] mining block. block 160. total 0: pending 0(added 0), local 0(added 0), queued 2040
-    tx_pool_test.go:3722: [12:09:43.112] mining block. block 161. total 0: pending 0(added 0), local 0(added 0), queued 2054
-    tx_pool_test.go:3722: [12:09:44.112] mining block. block 162. total 0: pending 0(added 0), local 0(added 0), queued 2067
-    tx_pool_test.go:3722: [12:09:45.112] mining block. block 163. total 0: pending 0(added 0), local 0(added 0), queued 2081
-    tx_pool_test.go:3722: [12:09:46.112] mining block. block 164. total 0: pending 0(added 0), local 0(added 0), queued 2094
-    tx_pool_test.go:3722: [12:09:47.111] mining block. block 165. total 0: pending 0(added 0), local 0(added 0), queued 2108
-    tx_pool_test.go:3722: [12:09:48.112] mining block. block 166. total 0: pending 0(added 0), local 0(added 0), queued 2121
-    tx_pool_test.go:3722: [12:09:49.112] mining block. block 167. total 0: pending 0(added 0), local 0(added 0), queued 2135
-    tx_pool_test.go:3722: [12:09:50.112] mining block. block 168. total 0: pending 0(added 0), local 0(added 0), queued 2148
-    tx_pool_test.go:3722: [12:09:51.112] mining block. block 169. total 0: pending 0(added 0), local 0(added 0), queued 2160
-    tx_pool_test.go:3722: [12:09:52.112] mining block. block 170. total 0: pending 0(added 0), local 0(added 0), queued 2176
-    tx_pool_test.go:3722: [12:09:53.112] mining block. block 171. total 0: pending 0(added 0), local 0(added 0), queued 2188
-    tx_pool_test.go:3722: [12:09:54.111] mining block. block 172. total 0: pending 0(added 0), local 0(added 0), queued 2202
-    tx_pool_test.go:3722: [12:09:55.112] mining block. block 173. total 0: pending 0(added 0), local 0(added 0), queued 2214
-    tx_pool_test.go:3722: [12:09:56.111] mining block. block 174. total 0: pending 0(added 0), local 0(added 0), queued 2227
-    tx_pool_test.go:3722: [12:09:57.112] mining block. block 175. total 0: pending 0(added 0), local 0(added 0), queued 2240
-    tx_pool_test.go:3722: [12:09:58.112] mining block. block 176. total 0: pending 0(added 0), local 0(added 0), queued 2252
-    tx_pool_test.go:3722: [12:09:59.112] mining block. block 177. total 0: pending 0(added 0), local 0(added 0), queued 2265
-    tx_pool_test.go:3722: [12:10:00.111] mining block. block 178. total 0: pending 0(added 0), local 0(added 0), queued 2279
-    tx_pool_test.go:3722: [12:10:01.111] mining block. block 179. total 0: pending 0(added 0), local 0(added 0), queued 2290
-    tx_pool_test.go:3722: [12:10:02.111] mining block. block 180. total 0: pending 0(added 0), local 0(added 0), queued 2303
-    tx_pool_test.go:3722: [12:10:03.112] mining block. block 181. total 0: pending 0(added 0), local 0(added 0), queued 2314
-    tx_pool_test.go:3722: [12:10:04.112] mining block. block 182. total 0: pending 0(added 0), local 0(added 0), queued 2327
-    tx_pool_test.go:3722: [12:10:05.112] mining block. block 183. total 0: pending 0(added 0), local 0(added 0), queued 2341
-    tx_pool_test.go:3722: [12:10:06.112] mining block. block 184. total 0: pending 0(added 0), local 0(added 0), queued 2353
-    tx_pool_test.go:3722: [12:10:07.111] mining block. block 185. total 0: pending 0(added 0), local 0(added 0), queued 2365
-    tx_pool_test.go:3722: [12:10:08.112] mining block. block 186. total 0: pending 0(added 0), local 0(added 0), queued 2380
-    tx_pool_test.go:3722: [12:10:09.112] mining block. block 187. total 0: pending 0(added 0), local 0(added 0), queued 2392
-    tx_pool_test.go:3722: [12:10:10.113] mining block. block 188. total 0: pending 0(added 0), local 0(added 0), queued 2406
-    tx_pool_test.go:3722: [12:10:11.112] mining block. block 189. total 0: pending 0(added 0), local 0(added 0), queued 2421
-    tx_pool_test.go:3722: [12:10:12.111] mining block. block 190. total 0: pending 0(added 0), local 0(added 0), queued 2434
-    tx_pool_test.go:3722: [12:10:13.112] mining block. block 191. total 0: pending 0(added 0), local 0(added 0), queued 2449
-    tx_pool_test.go:3722: [12:10:14.112] mining block. block 192. total 0: pending 0(added 0), local 0(added 0), queued 2462
-    tx_pool_test.go:3722: [12:10:15.111] mining block. block 193. total 0: pending 0(added 0), local 0(added 0), queued 2476
-    tx_pool_test.go:3722: [12:10:16.112] mining block. block 194. total 0: pending 0(added 0), local 0(added 0), queued 2490
-    tx_pool_test.go:3722: [12:10:17.111] mining block. block 195. total 0: pending 0(added 0), local 0(added 0), queued 2502
-    tx_pool_test.go:3722: [12:10:18.111] mining block. block 196. total 0: pending 0(added 0), local 0(added 0), queued 2515
-    tx_pool_test.go:3722: [12:10:19.112] mining block. block 197. total 0: pending 0(added 0), local 0(added 0), queued 2525
-    tx_pool_test.go:3722: [12:10:20.113] mining block. block 198. total 0: pending 0(added 0), local 0(added 0), queued 2537
-    tx_pool_test.go:3722: [12:10:21.112] mining block. block 199. total 0: pending 0(added 0), local 0(added 0), queued 2549
-    tx_pool_test.go:3722: [12:10:22.111] mining block. block 200. total 0: pending 0(added 0), local 0(added 0), queued 2562
-    tx_pool_test.go:3722: [12:10:23.111] mining block. block 201. total 0: pending 0(added 0), local 0(added 0), queued 2574
-    tx_pool_test.go:3722: [12:10:24.111] mining block. block 202. total 0: pending 0(added 0), local 0(added 0), queued 2587
-    tx_pool_test.go:3722: [12:10:25.112] mining block. block 203. total 0: pending 0(added 0), local 0(added 0), queued 2601
-    tx_pool_test.go:3722: [12:10:26.112] mining block. block 204. total 0: pending 0(added 0), local 0(added 0), queued 2615
-    tx_pool_test.go:3722: [12:10:27.112] mining block. block 205. total 0: pending 0(added 0), local 0(added 0), queued 2626
-    tx_pool_test.go:3722: [12:10:28.111] mining block. block 206. total 0: pending 0(added 0), local 0(added 0), queued 2640
-    tx_pool_test.go:3722: [12:10:29.111] mining block. block 207. total 0: pending 0(added 0), local 0(added 0), queued 2654
-    tx_pool_test.go:3722: [12:10:30.112] mining block. block 208. total 0: pending 0(added 0), local 0(added 0), queued 2665
-    tx_pool_test.go:3722: [12:10:31.111] mining block. block 209. total 0: pending 0(added 0), local 0(added 0), queued 2676
-    tx_pool_test.go:3722: [12:10:32.111] mining block. block 210. total 0: pending 0(added 0), local 0(added 0), queued 2689
-    tx_pool_test.go:3722: [12:10:33.111] mining block. block 211. total 0: pending 0(added 0), local 0(added 0), queued 2702
-    tx_pool_test.go:3722: [12:10:34.111] mining block. block 212. total 0: pending 0(added 0), local 0(added 0), queued 2716
-    tx_pool_test.go:3722: [12:10:35.112] mining block. block 213. total 0: pending 0(added 0), local 0(added 0), queued 2728
-    tx_pool_test.go:3722: [12:10:36.111] mining block. block 214. total 0: pending 0(added 0), local 0(added 0), queued 2741
-    tx_pool_test.go:3722: [12:10:37.112] mining block. block 215. total 0: pending 0(added 0), local 0(added 0), queued 2754
-    tx_pool_test.go:3722: [12:10:38.111] mining block. block 216. total 0: pending 0(added 0), local 0(added 0), queued 2767
-    tx_pool_test.go:3722: [12:10:39.112] mining block. block 217. total 0: pending 0(added 0), local 0(added 0), queued 2781
-    tx_pool_test.go:3722: [12:10:40.111] mining block. block 218. total 0: pending 0(added 0), local 0(added 0), queued 2793
-    tx_pool_test.go:3722: [12:10:41.111] mining block. block 219. total 0: pending 0(added 0), local 0(added 0), queued 2806
-    tx_pool_test.go:3722: [12:10:42.112] mining block. block 220. total 0: pending 0(added 0), local 0(added 0), queued 2819
-    tx_pool_test.go:3722: [12:10:43.111] mining block. block 221. total 0: pending 0(added 0), local 0(added 0), queued 2832
-    tx_pool_test.go:3722: [12:10:44.112] mining block. block 222. total 0: pending 0(added 0), local 0(added 0), queued 2847
-    tx_pool_test.go:3722: [12:10:45.112] mining block. block 223. total 0: pending 0(added 0), local 0(added 0), queued 2859
-    tx_pool_test.go:3722: [12:10:46.112] mining block. block 224. total 0: pending 0(added 0), local 0(added 0), queued 2871
-    tx_pool_test.go:3722: [12:10:47.112] mining block. block 225. total 0: pending 0(added 0), local 0(added 0), queued 2885
-    tx_pool_test.go:3722: [12:10:48.111] mining block. block 226. total 0: pending 0(added 0), local 0(added 0), queued 2900
-    tx_pool_test.go:3722: [12:10:49.112] mining block. block 227. total 0: pending 0(added 0), local 0(added 0), queued 2913
-    tx_pool_test.go:3722: [12:10:50.112] mining block. block 228. total 0: pending 0(added 0), local 0(added 0), queued 2926
-    tx_pool_test.go:3722: [12:10:51.111] mining block. block 229. total 0: pending 0(added 0), local 0(added 0), queued 2937
-    tx_pool_test.go:3722: [12:10:52.112] mining block. block 230. total 0: pending 0(added 0), local 0(added 0), queued 2949
-    tx_pool_test.go:3722: [12:10:53.112] mining block. block 231. total 0: pending 0(added 0), local 0(added 0), queued 2964
-    tx_pool_test.go:3722: [12:10:54.112] mining block. block 232. total 0: pending 0(added 0), local 0(added 0), queued 2977
-    tx_pool_test.go:3722: [12:10:55.112] mining block. block 233. total 0: pending 0(added 0), local 0(added 0), queued 2991
-    tx_pool_test.go:3722: [12:10:56.112] mining block. block 234. total 0: pending 0(added 0), local 0(added 0), queued 3005
-    tx_pool_test.go:3722: [12:10:57.111] mining block. block 235. total 0: pending 0(added 0), local 0(added 0), queued 3018
-    tx_pool_test.go:3722: [12:10:58.111] mining block. block 236. total 0: pending 0(added 0), local 0(added 0), queued 3035
-    tx_pool_test.go:3722: [12:10:59.111] mining block. block 237. total 0: pending 0(added 0), local 0(added 0), queued 3049
-    tx_pool_test.go:3722: [12:11:00.112] mining block. block 238. total 0: pending 0(added 0), local 0(added 0), queued 3065
-    tx_pool_test.go:3722: [12:11:01.111] mining block. block 239. total 0: pending 0(added 0), local 0(added 0), queued 3078
-    tx_pool_test.go:3722: [12:11:02.111] mining block. block 240. total 0: pending 0(added 0), local 0(added 0), queued 3092
-    tx_pool_test.go:3722: [12:11:03.112] mining block. block 241. total 0: pending 0(added 0), local 0(added 0), queued 3107
-    tx_pool_test.go:3722: [12:11:04.114] mining block. block 242. total 0: pending 0(added 0), local 0(added 0), queued 3123
-    tx_pool_test.go:3722: [12:11:05.112] mining block. block 243. total 0: pending 0(added 0), local 0(added 0), queued 3135
-    tx_pool_test.go:3722: [12:11:06.111] mining block. block 244. total 0: pending 0(added 0), local 0(added 0), queued 3148
-    tx_pool_test.go:3722: [12:11:07.112] mining block. block 245. total 0: pending 0(added 0), local 0(added 0), queued 3159
-    tx_pool_test.go:3722: [12:11:08.111] mining block. block 246. total 0: pending 0(added 0), local 0(added 0), queued 3172
-    tx_pool_test.go:3722: [12:11:09.112] mining block. block 247. total 0: pending 0(added 0), local 0(added 0), queued 3187
-    tx_pool_test.go:3722: [12:11:10.112] mining block. block 248. total 0: pending 0(added 0), local 0(added 0), queued 3198
-    tx_pool_test.go:3722: [12:11:11.111] mining block. block 249. total 0: pending 0(added 0), local 0(added 0), queued 3210
-    tx_pool_test.go:3722: [12:11:12.112] mining block. block 250. total 0: pending 0(added 0), local 0(added 0), queued 3221
-    tx_pool_test.go:3722: [12:11:13.113] mining block. block 251. total 0: pending 0(added 0), local 0(added 0), queued 3234
-    tx_pool_test.go:3722: [12:11:14.112] mining block. block 252. total 0: pending 0(added 0), local 0(added 0), queued 3247
-    tx_pool_test.go:3722: [12:11:15.111] mining block. block 253. total 0: pending 0(added 0), local 0(added 0), queued 3258
-    tx_pool_test.go:3722: [12:11:16.112] mining block. block 254. total 0: pending 0(added 0), local 0(added 0), queued 3268
-    tx_pool_test.go:3722: [12:11:17.111] mining block. block 255. total 0: pending 0(added 0), local 0(added 0), queued 3280
-    tx_pool_test.go:3722: [12:11:18.112] mining block. block 256. total 0: pending 0(added 0), local 0(added 0), queued 3294
-    tx_pool_test.go:3722: [12:11:19.111] mining block. block 257. total 0: pending 0(added 0), local 0(added 0), queued 3308
-    tx_pool_test.go:3722: [12:11:20.112] mining block. block 258. total 0: pending 0(added 0), local 0(added 0), queued 3322
-    tx_pool_test.go:3722: [12:11:21.112] mining block. block 259. total 0: pending 0(added 0), local 0(added 0), queued 3334
-    tx_pool_test.go:3722: [12:11:22.111] mining block. block 260. total 0: pending 0(added 0), local 0(added 0), queued 3346
-    tx_pool_test.go:3722: [12:11:23.111] mining block. block 261. total 0: pending 0(added 0), local 0(added 0), queued 3357
-    tx_pool_test.go:3722: [12:11:24.112] mining block. block 262. total 0: pending 0(added 0), local 0(added 0), queued 3371
-    tx_pool_test.go:3722: [12:11:25.112] mining block. block 263. total 0: pending 0(added 0), local 0(added 0), queued 3384
-    tx_pool_test.go:3722: [12:11:26.112] mining block. block 264. total 0: pending 0(added 0), local 0(added 0), queued 3396
-    tx_pool_test.go:3722: [12:11:27.112] mining block. block 265. total 0: pending 0(added 0), local 0(added 0), queued 3408
-    tx_pool_test.go:3722: [12:11:28.112] mining block. block 266. total 0: pending 0(added 0), local 0(added 0), queued 3422
-    tx_pool_test.go:3722: [12:11:29.111] mining block. block 267. total 0: pending 0(added 0), local 0(added 0), queued 3435
-    tx_pool_test.go:3722: [12:11:30.111] mining block. block 268. total 0: pending 0(added 0), local 0(added 0), queued 3447
-    tx_pool_test.go:3722: [12:11:31.112] mining block. block 269. total 0: pending 0(added 0), local 0(added 0), queued 3461
-    tx_pool_test.go:3722: [12:11:32.111] mining block. block 270. total 0: pending 0(added 0), local 0(added 0), queued 3474
-    tx_pool_test.go:3722: [12:11:33.112] mining block. block 271. total 0: pending 0(added 0), local 0(added 0), queued 3486
-    tx_pool_test.go:3722: [12:11:34.111] mining block. block 272. total 0: pending 0(added 0), local 0(added 0), queued 3501
-    tx_pool_test.go:3722: [12:11:35.112] mining block. block 273. total 0: pending 0(added 0), local 0(added 0), queued 3512
-    tx_pool_test.go:3722: [12:11:36.111] mining block. block 274. total 0: pending 0(added 0), local 0(added 0), queued 3525
-    tx_pool_test.go:3722: [12:11:37.111] mining block. block 275. total 0: pending 0(added 0), local 0(added 0), queued 3538
-    tx_pool_test.go:3722: [12:11:38.111] mining block. block 276. total 0: pending 0(added 0), local 0(added 0), queued 3552
-    tx_pool_test.go:3722: [12:11:39.111] mining block. block 277. total 0: pending 0(added 0), local 0(added 0), queued 3566
-    tx_pool_test.go:3722: [12:11:40.111] mining block. block 278. total 0: pending 0(added 0), local 0(added 0), queued 3578
-    tx_pool_test.go:3722: [12:11:41.111] mining block. block 279. total 0: pending 0(added 0), local 0(added 0), queued 3591
-    tx_pool_test.go:3722: [12:11:42.111] mining block. block 280. total 0: pending 0(added 0), local 0(added 0), queued 3604
-    tx_pool_test.go:3722: [12:11:43.111] mining block. block 281. total 0: pending 0(added 0), local 0(added 0), queued 3618
-    tx_pool_test.go:3722: [12:11:44.111] mining block. block 282. total 0: pending 0(added 0), local 0(added 0), queued 3628
-    tx_pool_test.go:3722: [12:11:45.110] mining block. block 283. total 0: pending 0(added 0), local 0(added 0), queued 3642
-    tx_pool_test.go:3722: [12:11:46.112] mining block. block 284. total 0: pending 0(added 0), local 0(added 0), queued 3655
-    tx_pool_test.go:3722: [12:11:47.111] mining block. block 285. total 0: pending 0(added 0), local 0(added 0), queued 3667
-    tx_pool_test.go:3722: [12:11:48.111] mining block. block 286. total 0: pending 0(added 0), local 0(added 0), queued 3682
-    tx_pool_test.go:3722: [12:11:49.111] mining block. block 287. total 0: pending 0(added 0), local 0(added 0), queued 3695
-    tx_pool_test.go:3722: [12:11:50.111] mining block. block 288. total 0: pending 0(added 0), local 0(added 0), queued 3709
-    tx_pool_test.go:3722: [12:11:51.112] mining block. block 289. total 0: pending 0(added 0), local 0(added 0), queued 3721
-    tx_pool_test.go:3722: [12:11:52.111] mining block. block 290. total 0: pending 0(added 0), local 0(added 0), queued 3734
-    tx_pool_test.go:3722: [12:11:53.111] mining block. block 291. total 0: pending 0(added 0), local 0(added 0), queued 3749
-    tx_pool_test.go:3722: [12:11:54.111] mining block. block 292. total 0: pending 0(added 0), local 0(added 0), queued 3762
-    tx_pool_test.go:3722: [12:11:55.112] mining block. block 293. total 0: pending 0(added 0), local 0(added 0), queued 3775
-    tx_pool_test.go:3722: [12:11:56.111] mining block. block 294. total 0: pending 0(added 0), local 0(added 0), queued 3787
-    tx_pool_test.go:3722: [12:11:57.111] mining block. block 295. total 0: pending 0(added 0), local 0(added 0), queued 3801
-    tx_pool_test.go:3722: [12:11:58.111] mining block. block 296. total 0: pending 0(added 0), local 0(added 0), queued 3811
-    tx_pool_test.go:3722: [12:11:59.111] mining block. block 297. total 0: pending 0(added 0), local 0(added 0), queued 3824
-    tx_pool_test.go:3722: [12:12:00.111] mining block. block 298. total 0: pending 0(added 0), local 0(added 0), queued 3839
-    tx_pool_test.go:3722: [12:12:01.111] mining block. block 299. total 0: pending 0(added 0), local 0(added 0), queued 3853
-    tx_pool_test.go:3722: [12:12:02.110] mining block. block 300. total 0: pending 0(added 0), local 0(added 0), queued 3866
-    tx_pool_test.go:3722: [12:12:03.114] mining block. block 301. total 0: pending 0(added 0), local 0(added 0), queued 3879
-    tx_pool_test.go:3722: [12:12:04.111] mining block. block 302. total 0: pending 0(added 0), local 0(added 0), queued 3893
-    tx_pool_test.go:3722: [12:12:05.111] mining block. block 303. total 0: pending 0(added 0), local 0(added 0), queued 3907
-    tx_pool_test.go:3722: [12:12:06.110] mining block. block 304. total 0: pending 0(added 0), local 0(added 0), queued 3920
-    tx_pool_test.go:3722: [12:12:07.110] mining block. block 305. total 0: pending 0(added 0), local 0(added 0), queued 3936
-    tx_pool_test.go:3722: [12:12:08.111] mining block. block 306. total 0: pending 0(added 0), local 0(added 0), queued 3948
-    tx_pool_test.go:3722: [12:12:09.111] mining block. block 307. total 0: pending 0(added 0), local 0(added 0), queued 3962
-    tx_pool_test.go:3722: [12:12:10.111] mining block. block 308. total 0: pending 0(added 0), local 0(added 0), queued 3974
-    tx_pool_test.go:3722: [12:12:11.111] mining block. block 309. total 0: pending 0(added 0), local 0(added 0), queued 3987
-    tx_pool_test.go:3722: [12:12:12.111] mining block. block 310. total 0: pending 0(added 0), local 0(added 0), queued 3998
-    tx_pool_test.go:3722: [12:12:13.112] mining block. block 311. total 0: pending 0(added 0), local 0(added 0), queued 4011
-    tx_pool_test.go:3722: [12:12:14.112] mining block. block 312. total 0: pending 0(added 0), local 0(added 0), queued 4024
-    tx_pool_test.go:3722: [12:12:15.111] mining block. block 313. total 0: pending 0(added 0), local 0(added 0), queued 4035
-    tx_pool_test.go:3722: [12:12:16.111] mining block. block 314. total 0: pending 0(added 0), local 0(added 0), queued 4047
-    tx_pool_test.go:3722: [12:12:17.112] mining block. block 315. total 0: pending 0(added 0), local 0(added 0), queued 4059
-    tx_pool_test.go:3722: [12:12:18.111] mining block. block 316. total 0: pending 0(added 0), local 0(added 0), queued 4074
-    tx_pool_test.go:3722: [12:12:19.111] mining block. block 317. total 0: pending 0(added 0), local 0(added 0), queued 4087
-    tx_pool_test.go:3722: [12:12:20.111] mining block. block 318. total 0: pending 0(added 0), local 0(added 0), queued 4099
-    tx_pool_test.go:3722: [12:12:21.111] mining block. block 319. total 0: pending 0(added 0), local 0(added 0), queued 4114
-    tx_pool_test.go:3722: [12:12:22.112] mining block. block 320. total 0: pending 0(added 0), local 0(added 0), queued 4126
-    tx_pool_test.go:3722: [12:12:23.111] mining block. block 321. total 0: pending 0(added 0), local 0(added 0), queued 4140
-    tx_pool_test.go:3722: [12:12:24.111] mining block. block 322. total 0: pending 0(added 0), local 0(added 0), queued 4153
-    tx_pool_test.go:3722: [12:12:25.111] mining block. block 323. total 0: pending 0(added 0), local 0(added 0), queued 4166
-    tx_pool_test.go:3722: [12:12:26.111] mining block. block 324. total 0: pending 0(added 0), local 0(added 0), queued 4179
-    tx_pool_test.go:3722: [12:12:27.111] mining block. block 325. total 0: pending 0(added 0), local 0(added 0), queued 4192
-    tx_pool_test.go:3722: [12:12:28.112] mining block. block 326. total 0: pending 0(added 0), local 0(added 0), queued 4205
-    tx_pool_test.go:3722: [12:12:29.111] mining block. block 327. total 0: pending 0(added 0), local 0(added 0), queued 4219
-    tx_pool_test.go:3722: [12:12:30.111] mining block. block 328. total 0: pending 0(added 0), local 0(added 0), queued 4229
-    tx_pool_test.go:3722: [12:12:31.111] mining block. block 329. total 0: pending 0(added 0), local 0(added 0), queued 4242
-    tx_pool_test.go:3722: [12:12:32.111] mining block. block 330. total 0: pending 0(added 0), local 0(added 0), queued 4254
-    tx_pool_test.go:3722: [12:12:33.111] mining block. block 331. total 0: pending 0(added 0), local 0(added 0), queued 4266
-    tx_pool_test.go:3722: [12:12:34.110] mining block. block 332. total 0: pending 0(added 0), local 0(added 0), queued 4277
-    tx_pool_test.go:3722: [12:12:35.111] mining block. block 333. total 0: pending 0(added 0), local 0(added 0), queued 4291
-    tx_pool_test.go:3722: [12:12:36.112] mining block. block 334. total 0: pending 0(added 0), local 0(added 0), queued 4303
-    tx_pool_test.go:3722: [12:12:37.111] mining block. block 335. total 0: pending 0(added 0), local 0(added 0), queued 4315
-    tx_pool_test.go:3722: [12:12:38.111] mining block. block 336. total 0: pending 0(added 0), local 0(added 0), queued 4328
-    tx_pool_test.go:3722: [12:12:39.112] mining block. block 337. total 0: pending 0(added 0), local 0(added 0), queued 4339
-    tx_pool_test.go:3722: [12:12:40.111] mining block. block 338. total 0: pending 0(added 0), local 0(added 0), queued 4353
-    tx_pool_test.go:3722: [12:12:41.111] mining block. block 339. total 0: pending 0(added 0), local 0(added 0), queued 4366
-    tx_pool_test.go:3722: [12:12:42.111] mining block. block 340. total 0: pending 0(added 0), local 0(added 0), queued 4378
-    tx_pool_test.go:3722: [12:12:43.111] mining block. block 341. total 0: pending 0(added 0), local 0(added 0), queued 4392
-    tx_pool_test.go:3722: [12:12:44.112] mining block. block 342. total 0: pending 0(added 0), local 0(added 0), queued 4406
-    tx_pool_test.go:3722: [12:12:45.110] mining block. block 343. total 0: pending 0(added 0), local 0(added 0), queued 4417
-    tx_pool_test.go:3722: [12:12:46.111] mining block. block 344. total 0: pending 0(added 0), local 0(added 0), queued 4429
-    tx_pool_test.go:3722: [12:12:47.111] mining block. block 345. total 0: pending 0(added 0), local 0(added 0), queued 4440
-    tx_pool_test.go:3722: [12:12:48.111] mining block. block 346. total 0: pending 0(added 0), local 0(added 0), queued 4453
-    tx_pool_test.go:3722: [12:12:49.111] mining block. block 347. total 0: pending 0(added 0), local 0(added 0), queued 4468
-    tx_pool_test.go:3722: [12:12:50.111] mining block. block 348. total 0: pending 0(added 0), local 0(added 0), queued 4480
-    tx_pool_test.go:3722: [12:12:51.110] mining block. block 349. total 0: pending 0(added 0), local 0(added 0), queued 4492
-    tx_pool_test.go:3722: [12:12:52.110] mining block. block 350. total 0: pending 0(added 0), local 0(added 0), queued 4504
-    tx_pool_test.go:3722: [12:12:53.110] mining block. block 351. total 0: pending 0(added 0), local 0(added 0), queued 4516
-    tx_pool_test.go:3722: [12:12:54.111] mining block. block 352. total 0: pending 0(added 0), local 0(added 0), queued 4528
-    tx_pool_test.go:3722: [12:12:55.111] mining block. block 353. total 0: pending 0(added 0), local 0(added 0), queued 4542
-    tx_pool_test.go:3722: [12:12:56.111] mining block. block 354. total 0: pending 0(added 0), local 0(added 0), queued 4555
-    tx_pool_test.go:3722: [12:12:57.110] mining block. block 355. total 0: pending 0(added 0), local 0(added 0), queued 4570
-    tx_pool_test.go:3722: [12:12:58.111] mining block. block 356. total 0: pending 0(added 0), local 0(added 0), queued 4582
-    tx_pool_test.go:3722: [12:12:59.111] mining block. block 357. total 0: pending 0(added 0), local 0(added 0), queued 4595
-    tx_pool_test.go:3722: [12:13:00.111] mining block. block 358. total 0: pending 0(added 0), local 0(added 0), queued 4609
-    tx_pool_test.go:3722: [12:13:01.111] mining block. block 359. total 0: pending 0(added 0), local 0(added 0), queued 4621
-    tx_pool_test.go:3722: [12:13:02.111] mining block. block 360. total 0: pending 0(added 0), local 0(added 0), queued 4634
-    tx_pool_test.go:3722: [12:13:03.111] mining block. block 361. total 0: pending 0(added 0), local 0(added 0), queued 4646
-    tx_pool_test.go:3722: [12:13:04.111] mining block. block 362. total 0: pending 0(added 0), local 0(added 0), queued 4659
-    tx_pool_test.go:3722: [12:13:05.111] mining block. block 363. total 0: pending 0(added 0), local 0(added 0), queued 4671
-    tx_pool_test.go:3722: [12:13:06.110] mining block. block 364. total 0: pending 0(added 0), local 0(added 0), queued 4683
-    tx_pool_test.go:3722: [12:13:07.111] mining block. block 365. total 0: pending 0(added 0), local 0(added 0), queued 4699
-    tx_pool_test.go:3722: [12:13:08.110] mining block. block 366. total 0: pending 0(added 0), local 0(added 0), queued 4713
-    tx_pool_test.go:3722: [12:13:09.112] mining block. block 367. total 0: pending 0(added 0), local 0(added 0), queued 4726
-    tx_pool_test.go:3722: [12:13:10.110] mining block. block 368. total 0: pending 0(added 0), local 0(added 0), queued 4738
-    tx_pool_test.go:3722: [12:13:11.110] mining block. block 369. total 0: pending 0(added 0), local 0(added 0), queued 4751
-    tx_pool_test.go:3722: [12:13:12.110] mining block. block 370. total 0: pending 0(added 0), local 0(added 0), queued 4765
-    tx_pool_test.go:3722: [12:13:13.110] mining block. block 371. total 0: pending 0(added 0), local 0(added 0), queued 4777
-    tx_pool_test.go:3722: [12:13:14.112] mining block. block 372. total 0: pending 0(added 0), local 0(added 0), queued 4790
-    tx_pool_test.go:3722: [12:13:15.111] mining block. block 373. total 0: pending 0(added 0), local 0(added 0), queued 4805
-    tx_pool_test.go:3722: [12:13:16.111] mining block. block 374. total 0: pending 0(added 0), local 0(added 0), queued 4817
-    tx_pool_test.go:3722: [12:13:17.115] mining block. block 375. total 0: pending 0(added 0), local 0(added 0), queued 4830
-    tx_pool_test.go:3722: [12:13:18.112] mining block. block 376. total 0: pending 0(added 0), local 0(added 0), queued 4841
-    tx_pool_test.go:3722: [12:13:19.111] mining block. block 377. total 0: pending 0(added 0), local 0(added 0), queued 4852
-    tx_pool_test.go:3722: [12:13:20.110] mining block. block 378. total 0: pending 0(added 0), local 0(added 0), queued 4865
-    tx_pool_test.go:3722: [12:13:21.112] mining block. block 379. total 0: pending 0(added 0), local 0(added 0), queued 4877
-    tx_pool_test.go:3722: [12:13:22.110] mining block. block 380. total 0: pending 0(added 0), local 0(added 0), queued 4890
-    tx_pool_test.go:3722: [12:13:23.111] mining block. block 381. total 0: pending 0(added 0), local 0(added 0), queued 4903
-    tx_pool_test.go:3722: [12:13:24.110] mining block. block 382. total 0: pending 0(added 0), local 0(added 0), queued 4917
-    tx_pool_test.go:3722: [12:13:25.112] mining block. block 383. total 0: pending 0(added 0), local 0(added 0), queued 4930
-    tx_pool_test.go:3722: [12:13:26.110] mining block. block 384. total 0: pending 0(added 0), local 0(added 0), queued 4941
-    tx_pool_test.go:3722: [12:13:27.110] mining block. block 385. total 0: pending 0(added 0), local 0(added 0), queued 4954
-    tx_pool_test.go:3722: [12:13:28.112] mining block. block 386. total 0: pending 0(added 0), local 0(added 0), queued 4966
-    tx_pool_test.go:3722: [12:13:29.110] mining block. block 387. total 0: pending 0(added 0), local 0(added 0), queued 4981
-    tx_pool_test.go:3722: [12:13:30.112] mining block. block 388. total 0: pending 0(added 0), local 0(added 0), queued 4994
-    tx_pool_test.go:3722: [12:13:31.112] mining block. block 389. total 0: pending 0(added 0), local 0(added 0), queued 5005
-    tx_pool_test.go:3722: [12:13:32.112] mining block. block 390. total 0: pending 0(added 0), local 0(added 0), queued 5017
-    tx_pool_test.go:3722: [12:13:33.110] mining block. block 391. total 0: pending 0(added 0), local 0(added 0), queued 5031
-    tx_pool_test.go:3722: [12:13:34.111] mining block. block 392. total 0: pending 0(added 0), local 0(added 0), queued 5043
-    tx_pool_test.go:3722: [12:13:35.110] mining block. block 393. total 0: pending 0(added 0), local 0(added 0), queued 5056
-    tx_pool_test.go:3722: [12:13:36.112] mining block. block 394. total 0: pending 0(added 0), local 0(added 0), queued 5071
-    tx_pool_test.go:3722: [12:13:37.110] mining block. block 395. total 0: pending 0(added 0), local 0(added 0), queued 5085
-    tx_pool_test.go:3722: [12:13:38.110] mining block. block 396. total 0: pending 0(added 0), local 0(added 0), queued 5100
-    tx_pool_test.go:3722: [12:13:39.112] mining block. block 397. total 0: pending 0(added 0), local 0(added 0), queued 5116
-    tx_pool_test.go:3722: [12:13:40.112] mining block. block 398. total 0: pending 0(added 0), local 0(added 0), queued 5129
-    tx_pool_test.go:3722: [12:13:41.110] mining block. block 399. total 0: pending 0(added 0), local 0(added 0), queued 5142
-    tx_pool_test.go:3722: [12:13:42.111] mining block. block 400. total 0: pending 0(added 0), local 0(added 0), queued 5153
-    tx_pool_test.go:3722: [12:13:43.111] mining block. block 401. total 0: pending 0(added 0), local 0(added 0), queued 5167
-    tx_pool_test.go:3722: [12:13:44.112] mining block. block 402. total 0: pending 0(added 0), local 0(added 0), queued 5177
-    tx_pool_test.go:3722: [12:13:45.111] mining block. block 403. total 0: pending 0(added 0), local 0(added 0), queued 5189
-    tx_pool_test.go:3722: [12:13:46.110] mining block. block 404. total 0: pending 0(added 0), local 0(added 0), queued 5202
-    tx_pool_test.go:3722: [12:13:47.111] mining block. block 405. total 0: pending 0(added 0), local 0(added 0), queued 5213
-    tx_pool_test.go:3722: [12:13:48.111] mining block. block 406. total 0: pending 0(added 0), local 0(added 0), queued 5226
-    tx_pool_test.go:3722: [12:13:49.111] mining block. block 407. total 0: pending 0(added 0), local 0(added 0), queued 5238
-    tx_pool_test.go:3722: [12:13:50.110] mining block. block 408. total 0: pending 0(added 0), local 0(added 0), queued 5248
-    tx_pool_test.go:3722: [12:13:51.110] mining block. block 409. total 0: pending 0(added 0), local 0(added 0), queued 5260
-    tx_pool_test.go:3722: [12:13:52.110] mining block. block 410. total 0: pending 0(added 0), local 0(added 0), queued 5273
-    tx_pool_test.go:3722: [12:13:53.111] mining block. block 411. total 0: pending 0(added 0), local 0(added 0), queued 5286
-    tx_pool_test.go:3722: [12:13:54.112] mining block. block 412. total 0: pending 0(added 0), local 0(added 0), queued 5299
-    tx_pool_test.go:3722: [12:13:55.112] mining block. block 413. total 0: pending 0(added 0), local 0(added 0), queued 5313
-    tx_pool_test.go:3722: [12:13:56.112] mining block. block 414. total 0: pending 0(added 0), local 0(added 0), queued 5324
-    tx_pool_test.go:3722: [12:13:57.112] mining block. block 415. total 0: pending 0(added 0), local 0(added 0), queued 5338
-    tx_pool_test.go:3722: [12:13:58.110] mining block. block 416. total 0: pending 0(added 0), local 0(added 0), queued 5351
-    tx_pool_test.go:3722: [12:13:59.112] mining block. block 417. total 0: pending 0(added 0), local 0(added 0), queued 5365
-    tx_pool_test.go:3722: [12:14:00.110] mining block. block 418. total 0: pending 0(added 0), local 0(added 0), queued 5380
-    tx_pool_test.go:3722: [12:14:01.114] mining block. block 419. total 0: pending 0(added 0), local 0(added 0), queued 5393
-    tx_pool_test.go:3722: [12:14:02.111] mining block. block 420. total 0: pending 0(added 0), local 0(added 0), queued 5404
-    tx_pool_test.go:3722: [12:14:03.112] mining block. block 421. total 0: pending 0(added 0), local 0(added 0), queued 5418
-    tx_pool_test.go:3722: [12:14:04.112] mining block. block 422. total 0: pending 0(added 0), local 0(added 0), queued 5430
-    tx_pool_test.go:3722: [12:14:05.112] mining block. block 423. total 0: pending 0(added 0), local 0(added 0), queued 5443
-    tx_pool_test.go:3722: [12:14:06.112] mining block. block 424. total 0: pending 0(added 0), local 0(added 0), queued 5456
-    tx_pool_test.go:3722: [12:14:07.111] mining block. block 425. total 0: pending 0(added 0), local 0(added 0), queued 5468
-    tx_pool_test.go:3722: [12:14:08.112] mining block. block 426. total 0: pending 0(added 0), local 0(added 0), queued 5479
-    tx_pool_test.go:3722: [12:14:09.112] mining block. block 427. total 0: pending 0(added 0), local 0(added 0), queued 5491
-    tx_pool_test.go:3722: [12:14:10.112] mining block. block 428. total 0: pending 0(added 0), local 0(added 0), queued 5506
-    tx_pool_test.go:3722: [12:14:11.110] mining block. block 429. total 0: pending 0(added 0), local 0(added 0), queued 5521
-    tx_pool_test.go:3722: [12:14:12.112] mining block. block 430. total 0: pending 0(added 0), local 0(added 0), queued 5532
-    tx_pool_test.go:3722: [12:14:13.110] mining block. block 431. total 0: pending 0(added 0), local 0(added 0), queued 5545
-    tx_pool_test.go:3722: [12:14:14.112] mining block. block 432. total 0: pending 0(added 0), local 0(added 0), queued 5560
-    tx_pool_test.go:3722: [12:14:15.110] mining block. block 433. total 0: pending 0(added 0), local 0(added 0), queued 5575
-    tx_pool_test.go:3722: [12:14:16.112] mining block. block 434. total 0: pending 0(added 0), local 0(added 0), queued 5588
-    tx_pool_test.go:3722: [12:14:17.111] mining block. block 435. total 0: pending 0(added 0), local 0(added 0), queued 5601
-    tx_pool_test.go:3722: [12:14:18.112] mining block. block 436. total 0: pending 0(added 0), local 0(added 0), queued 5611
-    tx_pool_test.go:3722: [12:14:19.110] mining block. block 437. total 0: pending 0(added 0), local 0(added 0), queued 5625
-    tx_pool_test.go:3722: [12:14:20.110] mining block. block 438. total 0: pending 0(added 0), local 0(added 0), queued 5637
-    tx_pool_test.go:3722: [12:14:21.112] mining block. block 439. total 0: pending 0(added 0), local 0(added 0), queued 5650
-    tx_pool_test.go:3722: [12:14:22.112] mining block. block 440. total 0: pending 0(added 0), local 0(added 0), queued 5663
-    tx_pool_test.go:3722: [12:14:23.111] mining block. block 441. total 0: pending 0(added 0), local 0(added 0), queued 5675
-    tx_pool_test.go:3722: [12:14:24.110] mining block. block 442. total 0: pending 0(added 0), local 0(added 0), queued 5687
-    tx_pool_test.go:3722: [12:14:25.112] mining block. block 443. total 0: pending 0(added 0), local 0(added 0), queued 5698
-    tx_pool_test.go:3722: [12:14:26.112] mining block. block 444. total 0: pending 0(added 0), local 0(added 0), queued 5710
-    tx_pool_test.go:3722: [12:14:27.111] mining block. block 445. total 0: pending 0(added 0), local 0(added 0), queued 5722
-    tx_pool_test.go:3722: [12:14:28.112] mining block. block 446. total 0: pending 0(added 0), local 0(added 0), queued 5734
-    tx_pool_test.go:3722: [12:14:29.110] mining block. block 447. total 0: pending 0(added 0), local 0(added 0), queued 5747
-    tx_pool_test.go:3722: [12:14:30.111] mining block. block 448. total 0: pending 0(added 0), local 0(added 0), queued 5759
-    tx_pool_test.go:3722: [12:14:31.110] mining block. block 449. total 0: pending 0(added 0), local 0(added 0), queued 5774
-    tx_pool_test.go:3722: [12:14:32.112] mining block. block 450. total 0: pending 0(added 0), local 0(added 0), queued 5784
-    tx_pool_test.go:3722: [12:14:33.110] mining block. block 451. total 0: pending 0(added 0), local 0(added 0), queued 5797
-    tx_pool_test.go:3722: [12:14:34.112] mining block. block 452. total 0: pending 0(added 0), local 0(added 0), queued 5810
-    tx_pool_test.go:3722: [12:14:35.111] mining block. block 453. total 0: pending 0(added 0), local 0(added 0), queued 5822
-    tx_pool_test.go:3722: [12:14:36.110] mining block. block 454. total 0: pending 0(added 0), local 0(added 0), queued 5835
-    tx_pool_test.go:3722: [12:14:37.111] mining block. block 455. total 0: pending 0(added 0), local 0(added 0), queued 5848
-    tx_pool_test.go:3722: [12:14:38.111] mining block. block 456. total 0: pending 0(added 0), local 0(added 0), queued 5861
-    tx_pool_test.go:3722: [12:14:39.112] mining block. block 457. total 0: pending 0(added 0), local 0(added 0), queued 5873
-    tx_pool_test.go:3722: [12:14:40.110] mining block. block 458. total 0: pending 0(added 0), local 0(added 0), queued 5889
-    tx_pool_test.go:3722: [12:14:41.112] mining block. block 459. total 0: pending 0(added 0), local 0(added 0), queued 5900
-    tx_pool_test.go:3722: [12:14:42.110] mining block. block 460. total 0: pending 0(added 0), local 0(added 0), queued 5915
-    tx_pool_test.go:3722: [12:14:43.111] mining block. block 461. total 0: pending 0(added 0), local 0(added 0), queued 5927
-    tx_pool_test.go:3722: [12:14:44.112] mining block. block 462. total 0: pending 0(added 0), local 0(added 0), queued 5938
-    tx_pool_test.go:3722: [12:14:45.111] mining block. block 463. total 0: pending 0(added 0), local 0(added 0), queued 5951
-    tx_pool_test.go:3722: [12:14:46.112] mining block. block 464. total 0: pending 0(added 0), local 0(added 0), queued 5962
-    tx_pool_test.go:3722: [12:14:47.111] mining block. block 465. total 0: pending 0(added 0), local 0(added 0), queued 5976
-    tx_pool_test.go:3722: [12:14:48.112] mining block. block 466. total 0: pending 0(added 0), local 0(added 0), queued 5988
-    tx_pool_test.go:3722: [12:14:49.111] mining block. block 467. total 0: pending 0(added 0), local 0(added 0), queued 6001
-    tx_pool_test.go:3722: [12:14:50.112] mining block. block 468. total 0: pending 0(added 0), local 0(added 0), queued 6013
-    tx_pool_test.go:3722: [12:14:51.112] mining block. block 469. total 0: pending 0(added 0), local 0(added 0), queued 6026
-    tx_pool_test.go:3722: [12:14:52.111] mining block. block 470. total 0: pending 0(added 0), local 0(added 0), queued 6041
-    tx_pool_test.go:3722: [12:14:53.112] mining block. block 471. total 0: pending 0(added 0), local 0(added 0), queued 6053
-    tx_pool_test.go:3722: [12:14:54.110] mining block. block 472. total 0: pending 0(added 0), local 0(added 0), queued 6067
-    tx_pool_test.go:3722: [12:14:55.112] mining block. block 473. total 0: pending 0(added 0), local 0(added 0), queued 6079
-    tx_pool_test.go:3722: [12:14:56.110] mining block. block 474. total 0: pending 0(added 0), local 0(added 0), queued 6089
-    tx_pool_test.go:3722: [12:14:57.110] mining block. block 475. total 0: pending 0(added 0), local 0(added 0), queued 6104
-    tx_pool_test.go:3722: [12:14:58.110] mining block. block 476. total 0: pending 0(added 0), local 0(added 0), queued 6118
-    tx_pool_test.go:3722: [12:14:59.110] mining block. block 477. total 0: pending 0(added 0), local 0(added 0), queued 6133
-    tx_pool_test.go:4148: AddRemoteSync error: transaction underpriced
-    tx_pool_test.go:4127: [12:14:59.831] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.836] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.883] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.888] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.935] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.939] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.987] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:14:59.990] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.039] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.041] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.091] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.092] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:00.112] mining block. block 478. total 0: pending 0(added 0), local 0(added 0), queued 6149
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.143] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.143] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.195] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.196] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.249] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.250] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.300] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.301] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.351] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.352] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.405] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.405] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.458] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.459] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.509] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.510] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.561] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.561] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.613] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.614] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.666] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.666] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.717] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.717] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.770] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.770] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.822] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.822] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.874] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.874] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.925] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.927] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.977] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:00.978] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.030] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.030] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.081] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.081] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:01.111] mining block. block 479. total 0: pending 0(added 0), local 0(added 0), queued 6162
-    tx_pool_test.go:4127: [12:15:01.134] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.134] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.186] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.186] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.236] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.237] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.288] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.288] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.339] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.340] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.393] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.394] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.444] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.445] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.495] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.496] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.547] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.548] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.598] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.599] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.649] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.649] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.701] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.701] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.753] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.754] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.804] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.805] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.857] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.858] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.909] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.909] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.961] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:01.963] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.014] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.015] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.066] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.066] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:02.112] mining block. block 480. total 0: pending 0(added 0), local 0(added 0), queued 6174
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.117] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.118] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.170] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.170] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.221] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.222] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.274] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.275] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.327] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.327] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.378] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.379] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.430] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.431] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.482] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.482] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.534] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.534] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.585] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.586] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.638] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.638] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.689] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.689] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.740] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.740] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.791] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.792] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.843] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.844] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.895] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.895] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.946] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.947] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.998] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:02.998] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.050] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.050] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.102] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.103] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:03.111] mining block. block 481. total 0: pending 0(added 0), local 0(added 0), queued 6188
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.154] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.155] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.207] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.207] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.259] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.260] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.310] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.311] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.362] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.362] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.414] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.414] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.466] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.466] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.518] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.518] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.570] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.570] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.622] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.622] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.675] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.676] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.725] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.726] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.777] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.778] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.829] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.829] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.883] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.884] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.934] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.934] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.984] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:03.985] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.036] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.036] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.087] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.087] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:04.112] mining block. block 482. total 0: pending 0(added 0), local 0(added 0), queued 6202
-    tx_pool_test.go:4127: [12:15:04.139] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.139] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.192] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.194] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.243] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.244] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.297] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.297] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.349] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.350] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.402] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.402] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.455] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.456] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.506] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.507] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.560] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.561] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.611] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.612] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.663] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.664] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.716] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.716] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.768] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.768] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.820] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.820] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.873] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.874] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.926] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.927] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.977] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:04.978] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.030] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.031] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.083] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.084] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:05.112] mining block. block 483. total 0: pending 0(added 0), local 0(added 0), queued 6215
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.134] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.134] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.189] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.189] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.240] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.240] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.291] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.292] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.344] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.345] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.396] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.397] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.448] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.449] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.499] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.500] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.551] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.552] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.604] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.605] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.656] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.657] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.708] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.709] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.761] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.761] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.814] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.814] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.865] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.866] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.917] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.919] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.970] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:05.970] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.022] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.022] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.073] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.073] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:06.111] mining block. block 484. total 0: pending 0(added 0), local 0(added 0), queued 6228
-    tx_pool_test.go:4127: [12:15:06.125] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.125] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.176] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.178] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.231] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.231] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.282] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.282] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.333] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.333] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.384] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.385] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.436] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.436] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.488] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.489] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.540] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.540] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.592] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.592] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.642] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.643] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.694] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.698] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.745] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.750] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.797] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.801] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.849] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.852] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.901] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.903] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.953] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:06.953] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.005] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.005] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.056] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.056] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.108] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.108] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:07.110] mining block. block 485. total 0: pending 0(added 0), local 0(added 0), queued 6241
-    tx_pool_test.go:4127: [12:15:07.161] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.161] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.213] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.214] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.266] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.266] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.317] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.317] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.370] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.371] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.421] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.422] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.474] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.474] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.526] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.527] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.580] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.581] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.633] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.634] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.685] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.685] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.736] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.737] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.788] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.788] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.840] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.840] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.891] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.893] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.945] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.946] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:07.999] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.003] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.052] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.054] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.105] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.105] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:08.110] mining block. block 486. total 0: pending 0(added 0), local 0(added 0), queued 6253
-    tx_pool_test.go:4127: [12:15:08.156] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.156] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.207] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.207] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.260] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.260] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.311] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.312] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.363] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.364] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.415] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.416] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.466] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.466] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.518] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.518] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.570] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.570] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.621] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.621] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.673] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.673] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.725] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.725] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.776] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.777] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.828] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.828] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.879] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.879] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.931] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.931] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.983] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:08.984] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.035] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.036] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.087] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.088] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:09.112] mining block. block 487. total 0: pending 0(added 0), local 0(added 0), queued 6266
-    tx_pool_test.go:4127: [12:15:09.140] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.140] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.192] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.192] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.244] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.244] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.295] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.296] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.348] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.349] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.404] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.404] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.454] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.455] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.507] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.508] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.559] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.560] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.612] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.612] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.663] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.664] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.716] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.716] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.767] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.767] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.818] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.818] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.871] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.871] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.923] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.923] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.975] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:09.975] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.027] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.027] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.078] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.079] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:10.110] mining block. block 488. total 0: pending 0(added 0), local 0(added 0), queued 6277
-    tx_pool_test.go:4127: [12:15:10.130] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.131] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.182] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.182] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.233] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.233] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.285] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.285] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.338] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.339] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.391] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.392] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.445] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.447] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.501] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.501] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.552] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.553] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.605] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.606] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.658] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.658] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.711] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.712] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.764] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.764] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.816] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.816] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.868] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.869] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.921] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.921] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.974] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:10.974] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.026] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.026] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.078] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.080] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:11.111] mining block. block 489. total 0: pending 0(added 0), local 0(added 0), queued 6290
-    tx_pool_test.go:4127: [12:15:11.130] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.131] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.183] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.183] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.235] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.235] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.288] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.288] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.339] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.340] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.392] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.393] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.443] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.443] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.494] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.494] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.545] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.547] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.598] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.599] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.649] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.650] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.700] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.701] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.752] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.753] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.804] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.804] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.855] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.856] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.908] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.909] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.962] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:11.962] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.014] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.014] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.066] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.066] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:12.110] mining block. block 490. total 0: pending 0(added 0), local 0(added 0), queued 6302
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.116] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.117] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.168] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.168] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.220] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.221] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.272] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.272] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.324] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.325] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.376] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.376] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.428] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.428] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.481] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.482] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.532] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.533] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.584] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.584] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.635] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.636] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.686] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.687] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.738] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.740] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.789] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.791] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.840] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.841] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.892] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.893] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.944] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.944] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.995] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:12.997] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.046] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.047] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.098] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.100] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:13.111] mining block. block 491. total 0: pending 0(added 0), local 0(added 0), queued 6317
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.150] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.151] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.202] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.203] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.254] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.254] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.305] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.305] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.359] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.359] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.411] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.412] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.462] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.462] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.514] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.514] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.566] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.566] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.618] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.618] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.670] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.670] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.723] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.724] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.774] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.775] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.827] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.827] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.877] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.878] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.930] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.931] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.981] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:13.982] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.033] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.034] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.086] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.086] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:14.112] mining block. block 492. total 0: pending 0(added 0), local 0(added 0), queued 6328
-    tx_pool_test.go:4127: [12:15:14.137] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.137] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.189] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.189] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.242] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.242] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.293] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.294] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.345] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.346] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.396] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.396] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.447] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.448] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.499] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.499] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.550] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.550] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.601] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.602] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.654] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.654] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.706] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.706] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.758] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.758] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.809] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.810] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.861] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.862] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.915] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.915] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.966] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:14.967] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.018] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.019] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.071] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.071] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:15.112] mining block. block 493. total 0: pending 0(added 0), local 0(added 0), queued 6342
-    tx_pool_test.go:4127: [12:15:15.123] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.124] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.175] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.175] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.228] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.228] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.280] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.280] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.332] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.332] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.384] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.385] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.436] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.437] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.489] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.490] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.541] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.543] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.593] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.594] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.646] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.646] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.699] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.700] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.750] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.751] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.802] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.803] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.853] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.854] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.905] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.905] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.957] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:15.958] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.009] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.010] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.062] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.063] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:16.112] mining block. block 494. total 0: pending 0(added 0), local 0(added 0), queued 6358
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.114] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.114] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.165] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.165] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.217] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.217] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.269] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.269] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.320] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.320] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.372] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.373] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.425] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.426] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.478] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.479] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.532] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.532] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.583] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.584] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.636] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.637] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.687] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.688] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.741] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.741] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.792] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.793] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.844] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.845] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.897] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.897] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.949] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:16.950] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.001] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.002] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.054] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.054] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.106] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.107] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:17.110] mining block. block 495. total 0: pending 0(added 0), local 0(added 0), queued 6371
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.158] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.159] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.210] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.210] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.262] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.263] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.326] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.327] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.378] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.378] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.430] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.430] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.483] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.483] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.534] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.534] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.585] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.585] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.636] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.637] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.689] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.689] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.741] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.741] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.793] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.794] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.846] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.847] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.897] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.898] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.951] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:17.951] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.002] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.002] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.054] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.055] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.107] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.107] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:18.110] mining block. block 496. total 0: pending 0(added 0), local 0(added 0), queued 6384
-    tx_pool_test.go:4127: [12:15:18.159] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.160] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.210] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.210] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.262] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.263] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.313] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.314] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.365] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.366] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.417] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.417] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.469] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.470] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.522] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.522] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.574] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.574] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.626] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.626] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.677] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.677] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.729] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.729] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.780] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.780] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.833] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.833] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.883] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.884] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.935] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.935] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.987] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:18.987] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.039] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.039] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.091] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.091] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:19.112] mining block. block 497. total 0: pending 0(added 0), local 0(added 0), queued 6397
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.143] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.143] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.195] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.195] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.248] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.248] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.299] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.300] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.351] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.351] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.402] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.403] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.454] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.454] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.506] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.506] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.558] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.558] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.609] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.610] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.661] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.662] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.712] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.712] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.763] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.764] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.816] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.816] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.867] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.867] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.918] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.918] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.969] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:19.969] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.021] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.022] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.074] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.074] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:20.111] mining block. block 498. total 0: pending 0(added 0), local 0(added 0), queued 6410
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.125] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.125] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.176] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.176] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.228] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.229] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.279] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.280] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.329] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.331] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.381] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.382] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.432] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.432] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.485] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.485] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.536] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.536] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.588] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.588] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.639] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.639] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.692] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.692] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.744] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.746] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.797] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.798] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.848] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.849] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.899] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.899] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.951] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:20.951] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.003] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.003] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.054] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.055] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.106] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.106] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:21.111] mining block. block 499. total 0: pending 0(added 0), local 0(added 0), queued 6422
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.159] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.159] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.209] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.210] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.261] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.262] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.314] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.316] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.366] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.367] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.418] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.418] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.470] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.471] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.522] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.523] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.574] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.575] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.625] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.626] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.676] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.676] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.731] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.731] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.784] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.785] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.836] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.837] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.886] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.889] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.939] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.940] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.990] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:21.991] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.041] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.042] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.093] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.093] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:22.112] mining block. block 500. total 0: pending 0(added 0), local 0(added 0), queued 6435
-    tx_pool_test.go:4127: [12:15:22.145] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.145] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.196] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.197] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.249] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.250] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.302] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.302] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.353] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.353] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.405] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.405] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.457] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.457] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.508] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.509] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.559] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.560] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.611] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.612] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.662] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.663] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.714] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.715] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.766] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.766] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.817] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.817] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.868] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.868] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.920] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.920] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.972] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:22.973] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.023] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.025] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.075] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.075] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:23.111] mining block. block 501. total 0: pending 0(added 0), local 0(added 0), queued 6447
-    tx_pool_test.go:4127: [12:15:23.126] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.127] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.178] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.178] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.231] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.231] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.283] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.284] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.336] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.336] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.387] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.387] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.438] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.449] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.491] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.500] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.543] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.551] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.594] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.603] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.645] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.655] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.697] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.707] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.749] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.760] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.802] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.812] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.854] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.866] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.904] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.919] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.956] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:23.971] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.009] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.022] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.060] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.074] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:24.112] mining block. block 502. total 0: pending 0(added 0), local 0(added 0), queued 6459
-    tx_pool_test.go:4127: [12:15:24.112] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.127] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.164] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.178] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.217] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.231] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.269] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.283] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.322] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.335] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.376] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.387] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.428] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.438] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.482] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.491] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.533] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.543] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.586] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.595] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.637] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.648] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.689] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.700] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.742] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.751] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.794] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.803] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.848] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.856] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.899] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.908] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.953] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:24.959] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.004] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.011] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.057] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.063] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.108] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:25.110] mining block. block 503. total 0: pending 0(added 0), local 0(added 0), queued 6472
-    tx_pool_test.go:4127: [12:15:25.115] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.161] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.166] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.212] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.217] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.263] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.269] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.314] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.321] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.369] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.371] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.422] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.422] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.472] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.473] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.525] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.526] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.579] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.580] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.633] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.634] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.684] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.685] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.736] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.736] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.788] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.791] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.841] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.843] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.894] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.894] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.945] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.945] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.996] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:25.996] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.049] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.050] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.100] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.101] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:26.110] mining block. block 504. total 0: pending 0(added 0), local 0(added 0), queued 6485
-    tx_pool_test.go:4127: [12:15:26.152] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.152] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.204] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.204] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.258] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.259] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.309] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.310] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.363] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.364] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.414] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.415] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.467] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.467] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.519] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.519] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.570] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.571] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.624] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.624] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.677] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.678] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.729] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.729] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.780] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.780] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.832] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.833] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.883] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.884] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.935] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.936] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.986] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:26.987] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.038] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.038] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.090] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.091] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:27.112] mining block. block 505. total 0: pending 0(added 0), local 0(added 0), queued 6497
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.142] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.143] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.193] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.194] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.246] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.246] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.303] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.303] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.355] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.357] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.408] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.408] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.460] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.460] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.511] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.512] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.563] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.563] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.616] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.616] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.667] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.668] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.721] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.722] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.773] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.773] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.824] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.825] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.875] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.876] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.926] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.927] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.977] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:27.977] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.028] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.028] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.078] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.079] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:28.112] mining block. block 506. total 0: pending 0(added 0), local 0(added 0), queued 6509
-    tx_pool_test.go:4127: [12:15:28.131] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.132] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.182] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.183] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.234] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.235] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.286] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.286] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.338] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.338] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.389] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.389] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.441] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.441] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.493] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.493] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.544] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.544] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.596] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.596] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.648] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.648] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.700] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.700] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.752] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.752] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.805] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.805] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.857] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.857] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.908] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.908] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.960] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:28.961] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.014] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.014] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.064] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.065] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:29.112] mining block. block 507. total 0: pending 0(added 0), local 0(added 0), queued 6521
-    tx_pool_test.go:4127: [12:15:29.115] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.115] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.167] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.167] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.219] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.219] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.271] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.271] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.324] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.326] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.375] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.377] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.432] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.433] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.483] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.484] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.534] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.535] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.586] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.586] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.638] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.638] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.689] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.691] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.740] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.743] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.791] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.794] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.842] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.846] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.893] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.897] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.947] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.948] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.999] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:29.999] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.050] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.051] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.102] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.103] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:30.110] mining block. block 508. total 0: pending 0(added 0), local 0(added 0), queued 6535
-    tx_pool_test.go:4127: [12:15:30.154] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.156] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.206] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.207] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.259] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.261] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.310] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.312] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.362] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.363] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.417] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.418] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.470] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.471] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.523] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.523] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.576] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.576] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.629] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.629] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.681] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.682] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.736] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.737] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.788] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.788] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.841] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.843] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.893] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.894] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.944] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.945] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.995] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:30.995] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.046] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.047] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.099] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.099] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:31.111] mining block. block 509. total 0: pending 0(added 0), local 0(added 0), queued 6549
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.151] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.151] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.202] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.203] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.255] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.256] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.306] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.307] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.359] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.359] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.411] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.411] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.464] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.464] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.516] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.516] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.566] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.567] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.618] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.619] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.670] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.672] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.727] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.728] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.780] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.782] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.833] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.833] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.884] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.884] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.936] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.936] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.988] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:31.988] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.040] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.040] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.091] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.091] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:32.112] mining block. block 510. total 0: pending 0(added 0), local 0(added 0), queued 6561
-    tx_pool_test.go:4127: [12:15:32.143] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.144] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.195] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.196] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.247] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.247] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.298] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.299] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.351] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.352] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.402] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.403] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.453] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.454] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.507] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.507] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.559] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.559] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.610] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.610] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.661] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.661] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.713] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.714] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.766] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.767] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.818] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.819] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.871] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.871] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.922] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.923] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.974] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:32.975] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.025] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.025] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.078] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.078] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:33.112] mining block. block 511. total 0: pending 0(added 0), local 0(added 0), queued 6573
-    tx_pool_test.go:4127: [12:15:33.130] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.130] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.182] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.182] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.234] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.237] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.286] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.288] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.337] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.339] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.388] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.390] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.441] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.441] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.492] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.493] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.549] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.549] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.600] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.600] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.652] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.652] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.704] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.704] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.756] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.757] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.809] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.810] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.861] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.862] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.913] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.913] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.964] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:33.965] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.016] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.016] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.069] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.069] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:34.112] mining block. block 512. total 0: pending 0(added 0), local 0(added 0), queued 6586
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.119] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.119] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.171] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.171] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.221] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.221] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.273] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.273] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.326] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.327] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.379] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.380] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.431] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.432] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.483] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.483] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.534] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.535] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.585] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.586] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.637] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.637] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.689] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.690] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.740] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.741] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.793] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.793] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.845] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.845] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.896] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.896] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.948] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.948] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:34.999] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.001] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.052] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.052] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.105] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.106] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:35.111] mining block. block 513. total 0: pending 0(added 0), local 0(added 0), queued 6599
-    tx_pool_test.go:4127: [12:15:35.158] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.158] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.210] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.212] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.263] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.264] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.317] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.318] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.369] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.370] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.421] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.422] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.472] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.473] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.524] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.524] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.578] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.579] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.631] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.631] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.682] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.682] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.733] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.734] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.786] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.787] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.837] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.839] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.889] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.890] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.941] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.941] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.991] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:35.992] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.044] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.047] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.097] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.098] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:36.111] mining block. block 514. total 0: pending 0(added 0), local 0(added 0), queued 6611
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.150] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.150] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.201] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.202] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.254] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.254] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.305] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.306] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.358] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.358] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.409] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.410] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.461] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.462] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.514] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.514] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.566] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.568] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.619] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.619] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.671] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.671] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.724] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.725] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.776] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.776] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.826] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.827] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.877] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.879] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.929] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.929] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.982] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:36.982] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.033] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.034] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.086] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.087] AddRemotes error: txpool is full
-    tx_pool_test.go:3722: [12:15:37.111] mining block. block 515. total 0: pending 0(added 0), local 0(added 0), queued 6624
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.138] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.139] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.190] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.190] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.241] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.242] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.294] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.294] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.345] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.346] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.399] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.401] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.451] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.453] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.502] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.503] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.555] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.556] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.607] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.608] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.659] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.660] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.713] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.713] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.767] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.767] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.819] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.821] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.872] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.872] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.923] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.923] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.975] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:37.975] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.027] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.028] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.079] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.080] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:38.110] mining block. block 516. total 0: pending 0(added 0), local 0(added 0), queued 6636
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.132] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.132] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.184] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.184] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.235] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.235] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.286] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.286] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.338] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.338] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.391] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.391] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.443] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.444] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.495] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.495] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.545] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.545] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.597] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.597] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.649] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.649] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.701] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.701] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.753] AddRemotes error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.753] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.805] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.805] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.858] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.858] AddRemotes error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4118: [12:15:38.909] stop AddRemotes
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.910] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:38.961] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.013] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.064] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:39.112] mining block. block 517. total 0: pending 0(added 0), local 0(added 0), queued 6647
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.115] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.165] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.217] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.269] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.322] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.375] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.428] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.478] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.530] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.583] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.637] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.688] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.739] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.791] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.843] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.895] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.946] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:39.997] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.050] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.103] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:40.110] mining block. block 518. total 0: pending 0(added 0), local 0(added 0), queued 6659
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.156] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.207] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.260] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.313] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.365] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.417] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.470] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.521] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.575] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.626] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.677] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.729] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.780] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.832] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.885] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.936] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:40.986] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.037] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.089] AddRemotesSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:41.112] mining block. block 519. total 0: pending 0(added 0), local 0(added 0), queued 6672
-    tx_pool_test.go:4127: [12:15:41.140] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.193] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.245] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.300] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.352] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.404] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.454] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.506] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.557] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.610] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.662] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.716] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.767] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.818] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.870] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.922] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4127: [12:15:41.974] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4127: [12:15:42.026] AddRemotesSync error: txpool is full
-    tx_pool_test.go:4118: [12:15:42.076] stop AddRemotesSync
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:42.112] mining block. block 520. total 0: pending 0(added 0), local 0(added 0), queued 6682
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:43.112] mining block. block 521. total 0: pending 0(added 0), local 0(added 0), queued 6694
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:44.112] mining block. block 522. total 0: pending 0(added 0), local 0(added 0), queued 6708
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:45.112] mining block. block 523. total 0: pending 0(added 0), local 0(added 0), queued 6718
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:46.111] mining block. block 524. total 0: pending 0(added 0), local 0(added 0), queued 6730
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:47.110] mining block. block 525. total 0: pending 0(added 0), local 0(added 0), queued 6745
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:48.112] mining block. block 526. total 0: pending 0(added 0), local 0(added 0), queued 6758
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:49.110] mining block. block 527. total 0: pending 0(added 0), local 0(added 0), queued 6770
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:50.110] mining block. block 528. total 0: pending 0(added 0), local 0(added 0), queued 6782
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:51.112] mining block. block 529. total 0: pending 0(added 0), local 0(added 0), queued 6794
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:52.111] mining block. block 530. total 0: pending 0(added 0), local 0(added 0), queued 6807
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:53.110] mining block. block 531. total 0: pending 0(added 0), local 0(added 0), queued 6821
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:54.110] mining block. block 532. total 0: pending 0(added 0), local 0(added 0), queued 6834
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:55.110] mining block. block 533. total 0: pending 0(added 0), local 0(added 0), queued 6848
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:56.110] mining block. block 534. total 0: pending 0(added 0), local 0(added 0), queued 6860
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:57.110] mining block. block 535. total 0: pending 0(added 0), local 0(added 0), queued 6873
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:15:58.110] mining block. block 536. total 0: pending 0(added 0), local 0(added 0), queued 6886
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:15:59.111] mining block. block 537. total 0: pending 0(added 0), local 0(added 0), queued 6898
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:00.110] mining block. block 538. total 0: pending 0(added 0), local 0(added 0), queued 6911
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:01.110] mining block. block 539. total 0: pending 0(added 0), local 0(added 0), queued 6922
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:02.111] mining block. block 540. total 0: pending 0(added 0), local 0(added 0), queued 6936
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:03.111] mining block. block 541. total 0: pending 0(added 0), local 0(added 0), queued 6948
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:04.112] mining block. block 542. total 0: pending 0(added 0), local 0(added 0), queued 6958
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:05.111] mining block. block 543. total 0: pending 0(added 0), local 0(added 0), queued 6972
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:06.111] mining block. block 544. total 0: pending 0(added 0), local 0(added 0), queued 6986
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:07.110] mining block. block 545. total 0: pending 0(added 0), local 0(added 0), queued 6999
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:08.111] mining block. block 546. total 0: pending 0(added 0), local 0(added 0), queued 7012
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:09.111] mining block. block 547. total 0: pending 0(added 0), local 0(added 0), queued 7023
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:10.111] mining block. block 548. total 0: pending 0(added 0), local 0(added 0), queued 7035
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:11.110] mining block. block 549. total 0: pending 0(added 0), local 0(added 0), queued 7049
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:12.112] mining block. block 550. total 0: pending 0(added 0), local 0(added 0), queued 7061
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:13.112] mining block. block 551. total 0: pending 0(added 0), local 0(added 0), queued 7075
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:14.112] mining block. block 552. total 0: pending 0(added 0), local 0(added 0), queued 7087
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:15.110] mining block. block 553. total 0: pending 0(added 0), local 0(added 0), queued 7103
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:16.111] mining block. block 554. total 0: pending 0(added 0), local 0(added 0), queued 7120
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:17.110] mining block. block 555. total 0: pending 0(added 0), local 0(added 0), queued 7134
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:18.112] mining block. block 556. total 0: pending 0(added 0), local 0(added 0), queued 7147
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:19.110] mining block. block 557. total 0: pending 0(added 0), local 0(added 0), queued 7162
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:20.111] mining block. block 558. total 0: pending 0(added 0), local 0(added 0), queued 7175
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:21.111] mining block. block 559. total 0: pending 0(added 0), local 0(added 0), queued 7185
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:22.111] mining block. block 560. total 0: pending 0(added 0), local 0(added 0), queued 7199
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:23.111] mining block. block 561. total 0: pending 0(added 0), local 0(added 0), queued 7211
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:24.111] mining block. block 562. total 0: pending 0(added 0), local 0(added 0), queued 7224
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:25.110] mining block. block 563. total 0: pending 0(added 0), local 0(added 0), queued 7240
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:26.110] mining block. block 564. total 0: pending 0(added 0), local 0(added 0), queued 7252
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:27.111] mining block. block 565. total 0: pending 0(added 0), local 0(added 0), queued 7264
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:28.109] mining block. block 566. total 0: pending 0(added 0), local 0(added 0), queued 7278
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:29.111] mining block. block 567. total 0: pending 0(added 0), local 0(added 0), queued 7292
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:30.111] mining block. block 568. total 0: pending 0(added 0), local 0(added 0), queued 7306
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:31.112] mining block. block 569. total 0: pending 0(added 0), local 0(added 0), queued 7318
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:32.111] mining block. block 570. total 0: pending 0(added 0), local 0(added 0), queued 7331
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:33.111] mining block. block 571. total 0: pending 0(added 0), local 0(added 0), queued 7344
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:34.111] mining block. block 572. total 0: pending 0(added 0), local 0(added 0), queued 7356
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:35.111] mining block. block 573. total 0: pending 0(added 0), local 0(added 0), queued 7368
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:36.111] mining block. block 574. total 0: pending 0(added 0), local 0(added 0), queued 7381
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:37.110] mining block. block 575. total 0: pending 0(added 0), local 0(added 0), queued 7394
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:38.111] mining block. block 576. total 0: pending 0(added 0), local 0(added 0), queued 7408
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:39.111] mining block. block 577. total 0: pending 0(added 0), local 0(added 0), queued 7419
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:40.110] mining block. block 578. total 0: pending 0(added 0), local 0(added 0), queued 7433
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:41.111] mining block. block 579. total 0: pending 0(added 0), local 0(added 0), queued 7445
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:42.111] mining block. block 580. total 0: pending 0(added 0), local 0(added 0), queued 7457
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:43.111] mining block. block 581. total 0: pending 0(added 0), local 0(added 0), queued 7469
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:44.111] mining block. block 582. total 0: pending 0(added 0), local 0(added 0), queued 7482
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:45.111] mining block. block 583. total 0: pending 0(added 0), local 0(added 0), queued 7495
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:46.110] mining block. block 584. total 0: pending 0(added 0), local 0(added 0), queued 7507
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:47.111] mining block. block 585. total 0: pending 0(added 0), local 0(added 0), queued 7518
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:48.110] mining block. block 586. total 0: pending 0(added 0), local 0(added 0), queued 7532
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:3722: [12:16:49.111] mining block. block 587. total 0: pending 0(added 0), local 0(added 0), queued 7543
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:50.112] mining block. block 588. total 0: pending 0(added 0), local 0(added 0), queued 7554
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:3722: [12:16:51.111] mining block. block 589. total 0: pending 0(added 0), local 0(added 0), queued 7567
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-    tx_pool_test.go:4148: AddRemoteSync error: txpool is full
-    tx_pool_test.go:4148: AddRemote error: txpool is full
-panic: test timed out after 10m0s
-
-goroutine 76959 [running]:
-testing.(*M).startAlarm.func1()
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:2036 +0xb4
-created by time.goFunc
-	/Users/jekamas/go/go1.19.2/src/time/sleep.go:176 +0x48
-
-goroutine 1 [chan receive, 10 minutes]:
-testing.(*T).Run(0xc000103380, {0x100bce526, 0x17}, 0x100f17d50)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1494 +0x57c
-testing.runTests.func1(0x0?)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1846 +0x94
-testing.tRunner(0xc000103380, 0xc0005afb98)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1446 +0x18c
-testing.runTests(0xc000368500?, {0x1013df840, 0x88, 0x88}, {0xc0001ef0b0?, 0x1002ff280?, 0x1013ec2e0?})
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1844 +0x6c4
-testing.(*M).Run(0xc000368500)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1726 +0x874
-main.main()
-	_testmain.go:407 +0x300
-
-goroutine 4 [chan receive]:
-github.com/ethereum/go-ethereum/metrics.(*meterArbiter).tick(0x1013ebda0)
-	/Users/jekamas/projects/bor/metrics/meter.go:290 +0x7c
-created by github.com/ethereum/go-ethereum/metrics.NewMeterForced
-	/Users/jekamas/projects/bor/metrics/meter.go:71 +0x138
-
-goroutine 5 [select]:
-github.com/ethereum/go-ethereum/consensus/ethash.(*remoteSealer).loop(0xc00035e000)
-	/Users/jekamas/projects/bor/consensus/ethash/sealer.go:280 +0x248
-created by github.com/ethereum/go-ethereum/consensus/ethash.startRemoteSealer
-	/Users/jekamas/projects/bor/consensus/ethash/sealer.go:264 +0x4fc
-
-goroutine 13 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 14 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 15 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 16 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 50 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 51 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 52 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 53 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 54 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 55 [chan receive, 10 minutes]:
-github.com/ethereum/go-ethereum/core.(*txSenderCacher).cache(0xc00030e3d0)
-	/Users/jekamas/projects/bor/core/tx_cacher.go:63 +0x54
-created by github.com/ethereum/go-ethereum/core.newTxSenderCacher
-	/Users/jekamas/projects/bor/core/tx_cacher.go:55 +0xa4
-
-goroutine 56 [chan receive, 10 minutes]:
-testing.(*T).Run(0xc000103520, {0xc00002838a, 0x6}, 0xc0000e7920)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1494 +0x57c
-github.com/ethereum/go-ethereum/core.TestPoolMiningDataRaces(0xc000103520)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3754 +0x294
-testing.tRunner(0xc000103520, 0x100f17d50)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1446 +0x18c
-created by testing.(*T).Run
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1493 +0x560
-
-goroutine 57 [chan receive]:
-github.com/ethereum/go-ethereum/core.apiWithMining({0x100f27e20, 0xc000103860}, {0x100bc5ae4, 0xd}, 0x2710, {{0xc00002838a?, 0xc000069de8?}, 0x10022dd44?}, 0x2540be400, 0xa, ...)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4103 +0x2afc
-github.com/ethereum/go-ethereum/core.TestPoolMiningDataRaces.func1(0xc000103860)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3769 +0xf0
-testing.tRunner(0xc000103860, 0xc0000e7920)
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1446 +0x18c
-created by testing.(*T).Run
-	/Users/jekamas/go/go1.19.2/src/testing/testing.go:1493 +0x560
-
-goroutine 58 [select]:
-github.com/ethereum/go-ethereum/core.(*TxPool).scheduleReorgLoop(0xc000024480)
-	/Users/jekamas/projects/bor/core/tx_pool.go:1413 +0x3d8
-created by github.com/ethereum/go-ethereum/core.NewTxPool
-	/Users/jekamas/projects/bor/core/tx_pool.go:336 +0xb04
-
-goroutine 59 [select]:
-github.com/ethereum/go-ethereum/core.(*TxPool).loop(0xc000024480)
-	/Users/jekamas/projects/bor/core/tx_pool.go:380 +0x338
-created by github.com/ethereum/go-ethereum/core.NewTxPool
-	/Users/jekamas/projects/bor/core/tx_pool.go:353 +0xe78
-
-goroutine 60 [sleep]:
-time.Sleep(0x2faf080)
-	/Users/jekamas/go/go1.19.2/src/runtime/time.go:195 +0x118
-github.com/ethereum/go-ethereum/core.apiWithMining.func2()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3901 +0x35c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3870 +0xd60
-
-goroutine 62 [sleep]:
-time.Sleep(0x2faf080)
-	/Users/jekamas/go/go1.19.2/src/runtime/time.go:195 +0x118
-github.com/ethereum/go-ethereum/core.addTransactions({0x100f27e20, 0xc000103860}, {0xc000784000, 0x2710, 0x0?}, 0xc0039f0000, 0x0?, 0x0?, 0x0?, {0x100bc2e58, ...}, ...)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4152 +0x258
-github.com/ethereum/go-ethereum/core.apiWithMining.func4()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3918 +0x13c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3915 +0x10a8
-
-goroutine 64 [sleep]:
-time.Sleep(0x2faf080)
-	/Users/jekamas/go/go1.19.2/src/runtime/time.go:195 +0x118
-github.com/ethereum/go-ethereum/core.addTransactions({0x100f27e20, 0xc000103860}, {0xc0007fc000, 0x2710, 0x0?}, 0xc001072050, 0x0?, 0x0?, 0x0?, {0x100bc5b80, ...}, ...)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4155 +0x21c
-github.com/ethereum/go-ethereum/core.apiWithMining.func6()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3935 +0x13c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3932 +0x13f0
-
-goroutine 65 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 66 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 67 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 68 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 69 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 70 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 71 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 72 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 73 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 74 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 75 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 76 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 77 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 78 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x0)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 79 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 80 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 81 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 82 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 83 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 84 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 85 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 86 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 87 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 88 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 89 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 90 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 91 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 92 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x1)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 93 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 94 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 95 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 96 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 97 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 114 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 115 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 116 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 117 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 118 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 119 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 120 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 121 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 122 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x2)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 123 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 124 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 125 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 126 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 127 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 128 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 129 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 130 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 131 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 132 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 133 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 134 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 135 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 136 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x3)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 137 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 138 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 139 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 140 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 141 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 142 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 143 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 144 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 145 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 146 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 147 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 148 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 149 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 150 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x4)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 151 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 152 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 153 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 154 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 155 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 156 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 157 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 158 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 159 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 160 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 161 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 178 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 179 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 180 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x5)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 181 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 182 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 183 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x2faf080?, 0x100f27e20?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 184 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x2540be400?, 0x2faf080?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 185 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x2faf080?, 0x100f27e20?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 186 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 187 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 188 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 189 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 190 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 191 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 192 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 193 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 194 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x6)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 195 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 196 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x2faf080?, 0x100f27e20?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 197 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x2faf080?, 0x100f27e20?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 198 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 199 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x2540be400?, 0x2faf080?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 200 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 201 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 202 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 203 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 204 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 205 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 206 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 207 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x100242634?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 208 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x7)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 209 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 210 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x2540be400?, 0x2faf080?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 211 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 212 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 213 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 214 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 215 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 216 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 217 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 218 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 219 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 220 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 221 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 222 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x8)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-
-goroutine 223 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc746e, 0xf}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func7()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3946 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3943 +0x15bc
-
-goroutine 224 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc8d26, 0x11}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func8()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3956 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3953 +0x1728
-
-goroutine 225 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfc18, 0x6}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func9()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3966 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3963 +0x1894
-
-goroutine 226 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc0e0c, 0x7}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func10()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3976 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3973 +0x1a00
-
-goroutine 227 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc72bb, 0xf}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func11()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3986 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3983 +0x1b6c
-
-goroutine 228 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc21ab, 0x8}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func12()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3996 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:3993 +0x1cd8
-
-goroutine 229 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc471b, 0xb}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func13()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4006 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4003 +0x1e44
-
-goroutine 230 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bc4521, 0xb}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func14()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4015 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4012 +0x1fd4
-
-goroutine 231 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0cc, 0x3}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func15()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4025 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4022 +0x218c
-
-goroutine 232 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbe0bd, 0x3}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func16()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4035 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4032 +0x2344
-
-goroutine 233 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbee73, 0x5}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func17()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4045 +0x15c
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4042 +0x24d4
-
-goroutine 234 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbef86, 0x5}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func18()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4055 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4052 +0x2640
-
-goroutine 235 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bbfda4, 0x6}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func19()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4065 +0x188
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4062 +0x27f8
-
-goroutine 236 [chan receive, 9 minutes]:
-github.com/ethereum/go-ethereum/core.runWithTicker({0x100f27e20, 0xc000103860}, 0x0?, 0x0?, {0x100bcb73c, 0x14}, 0x0?, 0x0?, 0x9)
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4183 +0x17c
-github.com/ethereum/go-ethereum/core.apiWithMining.func20()
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4075 +0x120
-created by github.com/ethereum/go-ethereum/core.apiWithMining
-	/Users/jekamas/projects/bor/core/tx_pool_test.go:4072 +0x1438
-FAIL	github.com/ethereum/go-ethereum/core	600.860s
-FAIL
-make: *** [test-txpool-race] Error 1

From 549d31280cae065f2a2725e0cffd3e6ff5db3c2d Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 00:44:22 +0400
Subject: [PATCH 87/96] fix test

---
 Makefile             |   4 +-
 core/tx_pool_test.go | 282 +++++++++++++++++++++++++++++++++----------
 2 files changed, 220 insertions(+), 66 deletions(-)

diff --git a/Makefile b/Makefile
index 9552ca2812..2dc746eef1 100644
--- a/Makefile
+++ b/Makefile
@@ -59,10 +59,10 @@ ios:
 	@echo "Import \"$(GOBIN)/Geth.framework\" to use the library."
 
 test:
-	$(GOTEST) --timeout 5m -shuffle=on -cover -short -coverprofile=cover.out $(TESTALL)
+	$(GOTEST) --timeout 5m -shuffle=on -cover -short -coverprofile=cover.out -covermode=atomic $(TESTALL)
 
 test-txpool-race:
-	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 10m -race -v ./core/
+	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 30m -race -v ./core/
 
 test-race:
 	$(GOTEST) --timeout 15m -race -shuffle=on $(TESTALL)
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 46058a8887..38fd369ac2 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3719,8 +3719,8 @@ func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.I
 		total += txRemoteCount
 	}
 
-	tb.Logf("[%s] mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d",
-		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen)
+	tb.Logf("[%s] mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d, localTxsCount %d, remoteTxsCount %d",
+		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen, localTxsCount, remoteTxsCount)
 
 	return total
 }
@@ -3755,18 +3755,19 @@ func TestPoolMiningDataRaces(t *testing.T) {
 			defer goleak.VerifyNone(t, leak.IgnoreList()...)
 
 			const (
-				blocks          = 600
-				blockGasLimit   = 40_000_000
-				blockPeriod     = time.Second
-				threads         = 10
-				batchesSize     = 10_000
-				timeoutDuration = 10 * blockPeriod
-				tickerDuration  = 50 * time.Millisecond
+				blocks            = 300
+				blockGasLimit     = 40_000_000
+				blockPeriod       = time.Second
+				threads           = 10
+				batchesSize       = 10_000
+				timeoutDuration   = 10 * blockPeriod
+				txsTickerDuration = 800 * time.Millisecond
+				apiTickerDuration = 10 * time.Millisecond
 
 				balanceStr = "1_000_000_000"
 			)
 
-			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, tickerDuration, blockPeriod, blocks, blockGasLimit)
+			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, txsTickerDuration, apiTickerDuration, blockPeriod, blocks, blockGasLimit)
 		})
 	}
 }
@@ -3775,7 +3776,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase struct {
 	name string
 	size int
-}, timeoutDuration time.Duration, threads int, tickerDuration time.Duration, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
+}, timeoutDuration time.Duration, threads int, txsTickerDuration time.Duration, apiTickerDuration time.Duration, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
 	done := make(chan struct{})
 
 	var wg sync.WaitGroup
@@ -3829,7 +3830,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remoteAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemote[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteKey)
+			batchesRemote[i][j] = transaction(uint64(j), 100_000, remoteKey)
 		}
 
 		batchesRemotes[i] = make(types.Transactions, singleCase.size)
@@ -3839,7 +3840,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remotesAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemotes[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remotesKey)
+			batchesRemotes[i][j] = transaction(uint64(j), 100_000, remotesKey)
 		}
 
 		batchesRemoteSync[i] = make(types.Transactions, singleCase.size)
@@ -3849,7 +3850,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remoteSyncAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemoteSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remoteSyncKey)
+			batchesRemoteSync[i][j] = transaction(uint64(j), 100_000, remoteSyncKey)
 		}
 
 		batchesRemotesSync[i] = make(types.Transactions, singleCase.size)
@@ -3859,7 +3860,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remotesSyncAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemotesSync[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, remotesSyncKey)
+			batchesRemotesSync[i][j] = transaction(uint64(j), 100_000, remotesSyncKey)
 		}
 	}
 
@@ -3868,14 +3869,25 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	// locals
 	wg.Add(1)
 	go func() {
-		defer wg.Done()
+		defer func() {
+			tb.Logf("[%s] stopping AddLocal(s)", common.NowMilliseconds())
+
+			wg.Done()
+
+			tb.Logf("[%s] stopped AddLocal(s)", common.NowMilliseconds())
+		}()
 
 		tb.Logf("[%s] starting AddLocal(s)", common.NowMilliseconds())
-		defer tb.Logf("[%s] stop AddLocal(s)", common.NowMilliseconds())
 
 		for _, batch := range batchesLocal {
 			batch := batch
 
+			select {
+			case <-done:
+				return
+			default:
+			}
+
 			if rand.Int()%2 == 0 {
 				runWithTimeout(tb, func(_ chan struct{}) {
 					errs := pool.AddLocals(batch)
@@ -3894,45 +3906,69 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 						}
 					}, done, "AddLocal", timeoutDuration, 0, 0)
 
-					time.Sleep(tickerDuration)
+					time.Sleep(txsTickerDuration)
 				}
 			}
 
-			time.Sleep(tickerDuration)
+			time.Sleep(txsTickerDuration)
 		}
 	}()
 
 	// remotes
 	wg.Add(1)
 	go func() {
-		defer wg.Done()
+		defer func() {
+			tb.Logf("[%s] stopping AddRemotes", common.NowMilliseconds())
 
-		addTransactionsBatches(tb, batchesRemotes, getFnForBatches(pool.AddRemotes), done, timeoutDuration, tickerDuration, "AddRemotes", 0)
+			wg.Done()
+
+			tb.Logf("[%s] stopped AddRemotes", common.NowMilliseconds())
+		}()
+
+		addTransactionsBatches(tb, batchesRemotes, getFnForBatches(pool.AddRemotes), done, timeoutDuration, txsTickerDuration, "AddRemotes", 0)
 	}()
 
 	// remote
 	wg.Add(1)
 	go func() {
-		defer wg.Done()
+		defer func() {
+			tb.Logf("[%s] stopping AddRemote", common.NowMilliseconds())
+
+			wg.Done()
 
-		addTransactions(tb, batchesRemote, pool.AddRemote, done, timeoutDuration, tickerDuration, "AddRemote", 0)
+			tb.Logf("[%s] stopped AddRemote", common.NowMilliseconds())
+		}()
+
+		addTransactions(tb, batchesRemote, pool.AddRemote, done, timeoutDuration, txsTickerDuration, "AddRemote", 0)
 	}()
 
 	// sync
 	// remotes
 	wg.Add(1)
 	go func() {
-		defer wg.Done()
+		defer func() {
+			tb.Logf("[%s] stopping AddRemotesSync", common.NowMilliseconds())
+
+			wg.Done()
+
+			tb.Logf("[%s] stopped AddRemotesSync", common.NowMilliseconds())
+		}()
 
-		go addTransactionsBatches(tb, batchesRemotesSync, getFnForBatches(pool.AddRemotesSync), done, timeoutDuration, tickerDuration, "AddRemotesSync", 0)
+		addTransactionsBatches(tb, batchesRemotesSync, getFnForBatches(pool.AddRemotesSync), done, timeoutDuration, txsTickerDuration, "AddRemotesSync", 0)
 	}()
 
 	// remote
 	wg.Add(1)
 	go func() {
-		defer wg.Done()
+		defer func() {
+			tb.Logf("[%s] stopping AddRemoteSync", common.NowMilliseconds())
+
+			wg.Done()
+
+			tb.Logf("[%s] stopped AddRemoteSync", common.NowMilliseconds())
+		}()
 
-		addTransactions(tb, batchesRemoteSync, pool.AddRemoteSync, done, timeoutDuration, tickerDuration, "AddRemoteSync", 0)
+		addTransactions(tb, batchesRemoteSync, pool.AddRemoteSync, done, timeoutDuration, txsTickerDuration, "AddRemoteSync", 0)
 	}()
 
 	// tx pool API
@@ -3941,149 +3977,235 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Pending-no-tips", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Pending-no-tips", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), false)
 				fmt.Fprint(io.Discard, p)
-			}, done, "Pending-no-tips", tickerDuration, timeoutDuration, i)
+			}, done, "Pending-no-tips", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Pending-with-tips", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Pending-with-tips", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				p := pool.Pending(context.Background(), true)
 				fmt.Fprint(io.Discard, p)
-			}, done, "Pending-with-tips", tickerDuration, timeoutDuration, i)
+			}, done, "Pending-with-tips", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Locals", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Locals", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				l := pool.Locals()
 				fmt.Fprint(io.Discard, l)
-			}, done, "Locals", tickerDuration, timeoutDuration, i)
+			}, done, "Locals", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Content", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Content", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.Content()
 				fmt.Fprint(io.Discard, p, q)
-			}, done, "Content", tickerDuration, timeoutDuration, i)
+			}, done, "Content", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping GasPriceUint256", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped GasPriceUint256", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.GasPriceUint256()
 				fmt.Fprint(io.Discard, res)
-			}, done, "GasPriceUint256", tickerDuration, timeoutDuration, i)
+			}, done, "GasPriceUint256", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping GasPrice", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped GasPrice", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.GasPrice()
 				fmt.Fprint(io.Discard, res)
-			}, done, "GasPrice", tickerDuration, timeoutDuration, i)
+			}, done, "GasPrice", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping SetGasPrice", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped SetGasPrice", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				pool.SetGasPrice(pool.GasPrice())
-			}, done, "SetGasPrice", tickerDuration, timeoutDuration, i)
+			}, done, "SetGasPrice", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping ContentFrom", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped ContentFrom", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.ContentFrom(account)
 				fmt.Fprint(io.Discard, p, q)
-			}, done, "ContentFrom", tickerDuration, timeoutDuration, i)
+			}, done, "ContentFrom", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Has", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Has", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.Has(batchesRemotes[0][0].Hash())
 				fmt.Fprint(io.Discard, res)
-			}, done, "Has", tickerDuration, timeoutDuration, i)
+			}, done, "Has", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Get", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Get", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				tx := pool.Get(batchesRemotes[0][0].Hash())
-				fmt.Fprint(io.Discard, tx.Hash())
-			}, done, "Get", tickerDuration, timeoutDuration, i)
+				fmt.Fprint(io.Discard, tx == nil)
+			}, done, "Get", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Nonce", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Nonce", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				res := pool.Nonce(account)
 				fmt.Fprint(io.Discard, res)
-			}, done, "Nonce", tickerDuration, timeoutDuration, i)
+			}, done, "Nonce", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Stats", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Stats", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				p, q := pool.Stats()
 				fmt.Fprint(io.Discard, p, q)
-			}, done, "Stats", tickerDuration, timeoutDuration, i)
+			}, done, "Stats", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping Status", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped Status", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
 				st := pool.Status([]common.Hash{batchesRemotes[1][0].Hash()})
 				fmt.Fprint(io.Discard, st)
-			}, done, "Status", tickerDuration, timeoutDuration, i)
+			}, done, "Status", apiTickerDuration, timeoutDuration, i)
 		}()
 
 		wg.Add(1)
 		go func() {
-			defer wg.Done()
+			defer func() {
+				tb.Logf("[%s] stopping SubscribeNewTxsEvent", common.NowMilliseconds())
+
+				wg.Done()
+
+				tb.Logf("[%s] stopped SubscribeNewTxsEvent", common.NowMilliseconds())
+			}()
 
 			runWithTicker(tb, func(c chan struct{}) {
 				ch := make(chan NewTxsEvent, 10)
 				sub := pool.SubscribeNewTxsEvent(ch)
+				defer sub.Unsubscribe()
 
 				select {
+				case <-done:
+					return
 				case <-c:
 				case res := <-ch:
 					fmt.Fprint(io.Discard, res)
 				}
 
-				sub.Unsubscribe()
-			}, done, "SubscribeNewTxsEvent", tickerDuration, timeoutDuration, i)
+			}, done, "SubscribeNewTxsEvent", apiTickerDuration, timeoutDuration, i)
 		}()
 	}
 
@@ -4121,6 +4243,12 @@ func addTransactionsBatches(tb testing.TB, batches []types.Transactions, fn func
 	for _, batch := range batches {
 		batch := batch
 
+		select {
+		case <-done:
+			return
+		default:
+		}
+
 		runWithTimeout(tb, func(_ chan struct{}) {
 			err := fn(batch)
 			if err != nil {
@@ -4142,6 +4270,12 @@ func addTransactions(tb testing.TB, batches []types.Transactions, fn func(*types
 		for _, tx := range batch {
 			tx := tx
 
+			select {
+			case <-done:
+				return
+			default:
+			}
+
 			runWithTimeout(tb, func(_ chan struct{}) {
 				err := fn(tx)
 				if err != nil {
@@ -4171,11 +4305,18 @@ func getFnForBatches(fn func([]*types.Transaction) []error) func(types.Transacti
 func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{}, name string, tickerDuration, timeoutDuration time.Duration, thread int) {
 	tb.Helper()
 
+	select {
+	case <-done:
+		tb.Logf("[%s] Short path. finishing outer runWithTicker for %q, thread %d", common.NowMilliseconds(), name, thread)
+		return
+	default:
+	}
+
 	defer func() {
 		tb.Logf("[%s] finishing outer runWithTicker for %q, thread %d", common.NowMilliseconds(), name, thread)
 	}()
 
-	localTicker := time.NewTimer(tickerDuration)
+	localTicker := time.NewTicker(tickerDuration)
 	defer localTicker.Stop()
 
 	n := 0
@@ -4196,6 +4337,14 @@ func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{},
 func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct{}, name string, timeoutDuration time.Duration, n, thread int) {
 	tb.Helper()
 
+	select {
+	case <-outerDone:
+		tb.Logf("[%s] Short path. exiting inner runWithTimeout by outer exit event for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
+
+		return
+	default:
+	}
+
 	/*
 		defer func() {
 			tb.Logf("[%s] finishing inner runWithTimeout for %q, thread %d, iteration %d",
@@ -4221,7 +4370,12 @@ func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct
 
 		*/
 
-		fn(doneCh)
+		select {
+		case <-outerDone:
+			return
+		default:
+			fn(doneCh)
+		}
 
 		/*
 			tb.Logf("[%s] finished inner runWithTimeout for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
@@ -4234,6 +4388,11 @@ func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct
 	var stack string
 
 	select {
+	case <-outerDone:
+		tb.Logf("[%s] exiting inner runWithTimeout by outer exit event for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
+	case <-doneCh:
+		// only for debug
+		//tb.Logf("[%s] exiting inner runWithTimeout by successful call for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
 	case <-timeout.C:
 		atomic.StoreInt32(isError, 1)
 
@@ -4242,10 +4401,5 @@ func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct
 		}
 
 		tb.Errorf("[%s] %s timeouted, thread %d, iteration %d. Stack %s", common.NowMilliseconds(), name, thread, n, stack)
-
-	case <-outerDone:
-		tb.Logf("[%s] exiting inner runWithTimeout by outer exit event for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
-	case <-doneCh:
-		// tb.Logf("[%s] exiting inner runWithTimeout by successful call for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
 	}
 }

From e0f6fe6060d5800d68cc58f7216558987c7aef61 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 00:49:23 +0400
Subject: [PATCH 88/96] add cacheMu

---
 core/tx_list.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/tx_list.go b/core/tx_list.go
index f5281282e5..d0341a9832 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -116,10 +116,12 @@ func (m *txSortedMap) Forward(threshold uint64) types.Transactions {
 	}
 
 	// If we had a cached order, shift the front
+	m.cacheMu.Lock()
 	if m.cache != nil {
 		hitCacheCounter.Inc(1)
 		m.cache = m.cache[len(removed):]
 	}
+	m.cacheMu.Unlock()
 
 	return removed
 }
@@ -206,9 +208,11 @@ func (m *txSortedMap) Cap(threshold int) types.Transactions {
 	heap.Init(m.index)
 
 	// If we had a cache, shift the back
+	m.cacheMu.Lock()
 	if m.cache != nil {
 		m.cache = m.cache[:len(m.cache)-len(drops)]
 	}
+	m.cacheMu.Unlock()
 
 	return drops
 }

From 7db77bea37214e7e123c3d9c75c5a9d7dae96aef Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 01:23:49 +0400
Subject: [PATCH 89/96] more tests

---
 Makefile             |   2 +-
 core/tx_list.go      |   8 +--
 core/tx_pool_test.go | 141 +++++++++++++++++++++++++++++++++++++------
 3 files changed, 127 insertions(+), 24 deletions(-)

diff --git a/Makefile b/Makefile
index 2dc746eef1..52fbc4caf9 100644
--- a/Makefile
+++ b/Makefile
@@ -62,7 +62,7 @@ test:
 	$(GOTEST) --timeout 5m -shuffle=on -cover -short -coverprofile=cover.out -covermode=atomic $(TESTALL)
 
 test-txpool-race:
-	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 30m -race -v ./core/
+	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 300m -race -v ./core/
 
 test-race:
 	$(GOTEST) --timeout 15m -race -shuffle=on $(TESTALL)
diff --git a/core/tx_list.go b/core/tx_list.go
index d0341a9832..518aebea33 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -298,17 +298,15 @@ func (m *txSortedMap) flatten() types.Transactions {
 	m.cacheMu.Lock()
 	defer m.cacheMu.Unlock()
 
-	cache := m.cache
-
 	if m.isEmpty {
 		m.isEmpty = false // to simulate sync.Once
 
 		m.cacheMu.Unlock()
 
-		cache = make(types.Transactions, 0, len(m.items))
-
 		m.m.RLock()
 
+		cache := make(types.Transactions, 0, len(m.items))
+
 		for _, tx := range m.items {
 			cache = append(cache, tx)
 		}
@@ -327,7 +325,7 @@ func (m *txSortedMap) flatten() types.Transactions {
 		hitCacheCounter.Inc(1)
 	}
 
-	return cache
+	return m.cache
 }
 
 func (m *txSortedMap) lastElement() *types.Transaction {
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 38fd369ac2..5b385be0ad 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3734,13 +3734,115 @@ func TestPoolMiningDataRaces(t *testing.T) {
 	const format = "size %d"
 
 	cases := []struct {
-		name string
-		size int
+		name              string
+		size              int
+		txsTickerDuration time.Duration
+		apiTickerDuration time.Duration
 	}{
-		{size: 1},
-		{size: 5},
-		{size: 10},
-		{size: 20},
+		{
+			size:              1,
+			txsTickerDuration: 200 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              1,
+			txsTickerDuration: 400 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              1,
+			txsTickerDuration: 600 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              1,
+			txsTickerDuration: 800 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+
+		{
+			size:              5,
+			txsTickerDuration: 200 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              5,
+			txsTickerDuration: 400 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              5,
+			txsTickerDuration: 600 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              5,
+			txsTickerDuration: 800 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+
+		{
+			size:              10,
+			txsTickerDuration: 200 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              10,
+			txsTickerDuration: 400 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              10,
+			txsTickerDuration: 600 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              10,
+			txsTickerDuration: 800 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+
+		{
+			size:              20,
+			txsTickerDuration: 200 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              20,
+			txsTickerDuration: 400 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              20,
+			txsTickerDuration: 600 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              20,
+			txsTickerDuration: 800 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+
+		{
+			size:              30,
+			txsTickerDuration: 200 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              30,
+			txsTickerDuration: 400 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              30,
+			txsTickerDuration: 600 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
+		{
+			size:              30,
+			txsTickerDuration: 800 * time.Millisecond,
+			apiTickerDuration: 10 * time.Millisecond,
+		},
 	}
 
 	for i := range cases {
@@ -3755,28 +3857,28 @@ func TestPoolMiningDataRaces(t *testing.T) {
 			defer goleak.VerifyNone(t, leak.IgnoreList()...)
 
 			const (
-				blocks            = 300
-				blockGasLimit     = 40_000_000
-				blockPeriod       = time.Second
-				threads           = 10
-				batchesSize       = 10_000
-				timeoutDuration   = 10 * blockPeriod
-				txsTickerDuration = 800 * time.Millisecond
-				apiTickerDuration = 10 * time.Millisecond
+				blocks          = 300
+				blockGasLimit   = 40_000_000
+				blockPeriod     = time.Second
+				threads         = 10
+				batchesSize     = 10_000
+				timeoutDuration = 10 * blockPeriod
 
 				balanceStr = "1_000_000_000"
 			)
 
-			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, txsTickerDuration, apiTickerDuration, blockPeriod, blocks, blockGasLimit)
+			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, blockPeriod, blocks, blockGasLimit)
 		})
 	}
 }
 
 //nolint:gocognit,thelper
 func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase struct {
-	name string
-	size int
-}, timeoutDuration time.Duration, threads int, txsTickerDuration time.Duration, apiTickerDuration time.Duration, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
+	name              string
+	size              int
+	txsTickerDuration time.Duration
+	apiTickerDuration time.Duration
+}, timeoutDuration time.Duration, threads int, blockPeriod time.Duration, blocks int, blockGasLimit uint64) {
 	done := make(chan struct{})
 
 	var wg sync.WaitGroup
@@ -3866,6 +3968,9 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	tb.Logf("[%s] starting goroutines", common.NowMilliseconds())
 
+	txsTickerDuration := singleCase.txsTickerDuration
+	apiTickerDuration := singleCase.apiTickerDuration
+
 	// locals
 	wg.Add(1)
 	go func() {

From e4178d1364442a0ff17763eb2178f3cf7e68a565 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 02:00:40 +0400
Subject: [PATCH 90/96] fix test panic

---
 core/tx_pool_test.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 5b385be0ad..adc0b8e162 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -4300,6 +4300,11 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 			runWithTicker(tb, func(c chan struct{}) {
 				ch := make(chan NewTxsEvent, 10)
 				sub := pool.SubscribeNewTxsEvent(ch)
+
+				if sub == nil {
+					return
+				}
+
 				defer sub.Unsubscribe()
 
 				select {

From 57c48776e6c460e1da9564f9fcab268037b0548d Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 09:21:39 +0400
Subject: [PATCH 91/96] linters

---
 Makefile              |   2 +-
 common/debug/debug.go |   4 +-
 core/tx_pool_test.go  | 117 ++++++++++++++++++++++--------------------
 3 files changed, 65 insertions(+), 58 deletions(-)

diff --git a/Makefile b/Makefile
index 52fbc4caf9..a79b287ac7 100644
--- a/Makefile
+++ b/Makefile
@@ -62,7 +62,7 @@ test:
 	$(GOTEST) --timeout 5m -shuffle=on -cover -short -coverprofile=cover.out -covermode=atomic $(TESTALL)
 
 test-txpool-race:
-	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 300m -race -v ./core/
+	$(GOTEST) -run=TestPoolMiningDataRaces --timeout 600m -race -v ./core/
 
 test-race:
 	$(GOTEST) --timeout 15m -race -shuffle=on $(TESTALL)
diff --git a/common/debug/debug.go b/common/debug/debug.go
index 6c1681859e..056ebe2fa7 100644
--- a/common/debug/debug.go
+++ b/common/debug/debug.go
@@ -40,13 +40,13 @@ func CodeLineStr() string {
 
 func Stack(all bool) []byte {
 	buf := make([]byte, 4096)
+
 	for {
 		n := runtime.Stack(buf, all)
 		if n < len(buf) {
 			return buf[:n]
 		}
+
 		buf = make([]byte, 2*len(buf))
 	}
-
-	return buf
 }
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index adc0b8e162..d99e4c8fde 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -3731,7 +3731,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 		t.Skip("only for data race testing")
 	}
 
-	const format = "size %d"
+	const format = "size %d, txs ticker %v, api ticker %v"
 
 	cases := []struct {
 		name              string
@@ -3846,7 +3846,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 	}
 
 	for i := range cases {
-		cases[i].name = fmt.Sprintf(format, cases[i].size)
+		cases[i].name = fmt.Sprintf(format, cases[i].size, cases[i].txsTickerDuration, cases[i].apiTickerDuration)
 	}
 
 	//nolint:paralleltest
@@ -3864,7 +3864,7 @@ func TestPoolMiningDataRaces(t *testing.T) {
 				batchesSize     = 10_000
 				timeoutDuration = 10 * blockPeriod
 
-				balanceStr = "1_000_000_000"
+				balanceStr = "1_000_000_000_000"
 			)
 
 			apiWithMining(t, balanceStr, batchesSize, singleCase, timeoutDuration, threads, blockPeriod, blocks, blockGasLimit)
@@ -3922,7 +3922,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		batchesLocal[i] = make(types.Transactions, singleCase.size)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesLocal[i][j] = transaction(uint64(singleCase.size*i+j), 100_000, localKey)
+			batchesLocal[i][j] = pricedTransaction(uint64(singleCase.size*i+j), 100_000, big.NewInt(int64(i+1)), localKey)
 		}
 
 		batchesRemote[i] = make(types.Transactions, singleCase.size)
@@ -3932,7 +3932,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remoteAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemote[i][j] = transaction(uint64(j), 100_000, remoteKey)
+			batchesRemote[i][j] = pricedTransaction(uint64(j), 100_000, big.NewInt(int64(i+1)), remoteKey)
 		}
 
 		batchesRemotes[i] = make(types.Transactions, singleCase.size)
@@ -3942,7 +3942,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remotesAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemotes[i][j] = transaction(uint64(j), 100_000, remotesKey)
+			batchesRemotes[i][j] = pricedTransaction(uint64(j), 100_000, big.NewInt(int64(i+1)), remotesKey)
 		}
 
 		batchesRemoteSync[i] = make(types.Transactions, singleCase.size)
@@ -3952,7 +3952,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remoteSyncAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemoteSync[i][j] = transaction(uint64(j), 100_000, remoteSyncKey)
+			batchesRemoteSync[i][j] = pricedTransaction(uint64(j), 100_000, big.NewInt(int64(i+1)), remoteSyncKey)
 		}
 
 		batchesRemotesSync[i] = make(types.Transactions, singleCase.size)
@@ -3962,7 +3962,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		testAddBalance(pool, remotesSyncAddr, balance)
 
 		for j := 0; j < singleCase.size; j++ {
-			batchesRemotesSync[i][j] = transaction(uint64(j), 100_000, remotesSyncKey)
+			batchesRemotesSync[i][j] = pricedTransaction(uint64(j), 100_000, big.NewInt(int64(i+1)), remotesSyncKey)
 		}
 	}
 
@@ -3973,6 +3973,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// locals
 	wg.Add(1)
+
 	go func() {
 		defer func() {
 			tb.Logf("[%s] stopping AddLocal(s)", common.NowMilliseconds())
@@ -4021,6 +4022,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// remotes
 	wg.Add(1)
+
 	go func() {
 		defer func() {
 			tb.Logf("[%s] stopping AddRemotes", common.NowMilliseconds())
@@ -4035,6 +4037,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// remote
 	wg.Add(1)
+
 	go func() {
 		defer func() {
 			tb.Logf("[%s] stopping AddRemote", common.NowMilliseconds())
@@ -4050,6 +4053,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	// sync
 	// remotes
 	wg.Add(1)
+
 	go func() {
 		defer func() {
 			tb.Logf("[%s] stopping AddRemotesSync", common.NowMilliseconds())
@@ -4064,6 +4068,7 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 
 	// remote
 	wg.Add(1)
+
 	go func() {
 		defer func() {
 			tb.Logf("[%s] stopping AddRemoteSync", common.NowMilliseconds())
@@ -4081,13 +4086,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		i := i
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Pending-no-tips", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Pending-no-tips, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Pending-no-tips", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Pending-no-tips, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4097,13 +4103,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Pending-with-tips", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Pending-with-tips, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Pending-with-tips", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Pending-with-tips, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4113,13 +4120,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Locals", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Locals, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Locals", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Locals, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4129,13 +4137,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Content", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Content, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Content", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Content, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4145,13 +4154,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping GasPriceUint256", common.NowMilliseconds())
+				tb.Logf("[%s] stopping GasPriceUint256, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped GasPriceUint256", common.NowMilliseconds())
+				tb.Logf("[%s] stopped GasPriceUint256, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4161,13 +4171,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping GasPrice", common.NowMilliseconds())
+				tb.Logf("[%s] stopping GasPrice, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped GasPrice", common.NowMilliseconds())
+				tb.Logf("[%s] stopped GasPrice, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4177,13 +4188,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping SetGasPrice", common.NowMilliseconds())
+				tb.Logf("[%s] stopping SetGasPrice, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped SetGasPrice", common.NowMilliseconds())
+				tb.Logf("[%s] stopped SetGasPrice, , thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4192,13 +4204,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping ContentFrom", common.NowMilliseconds())
+				tb.Logf("[%s] stopping ContentFrom, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped ContentFrom", common.NowMilliseconds())
+				tb.Logf("[%s] stopped ContentFrom, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4208,13 +4221,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Has", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Has, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Has", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Has, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4224,13 +4238,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Get", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Get, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Get", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Get, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4240,13 +4255,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Nonce", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Nonce, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Nonce", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Nonce, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4256,13 +4272,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Stats", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Stats, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Stats", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Stats, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4272,13 +4289,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping Status", common.NowMilliseconds())
+				tb.Logf("[%s] stopping Status, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped Status", common.NowMilliseconds())
+				tb.Logf("[%s] stopped Status, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(_ chan struct{}) {
@@ -4288,13 +4306,14 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		}()
 
 		wg.Add(1)
+
 		go func() {
 			defer func() {
-				tb.Logf("[%s] stopping SubscribeNewTxsEvent", common.NowMilliseconds())
+				tb.Logf("[%s] stopping SubscribeNewTxsEvent, thread %d", common.NowMilliseconds(), i)
 
 				wg.Done()
 
-				tb.Logf("[%s] stopped SubscribeNewTxsEvent", common.NowMilliseconds())
+				tb.Logf("[%s] stopped SubscribeNewTxsEvent, thread %d", common.NowMilliseconds(), i)
 			}()
 
 			runWithTicker(tb, func(c chan struct{}) {
@@ -4345,7 +4364,10 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 }
 
 func addTransactionsBatches(tb testing.TB, batches []types.Transactions, fn func(types.Transactions) error, done chan struct{}, timeoutDuration time.Duration, tickerDuration time.Duration, name string, thread int) {
+	tb.Helper()
+
 	tb.Logf("[%s] starting %s", common.NowMilliseconds(), name)
+
 	defer func() {
 		tb.Logf("[%s] stop %s", common.NowMilliseconds(), name)
 	}()
@@ -4371,7 +4393,10 @@ func addTransactionsBatches(tb testing.TB, batches []types.Transactions, fn func
 }
 
 func addTransactions(tb testing.TB, batches []types.Transactions, fn func(*types.Transaction) error, done chan struct{}, timeoutDuration time.Duration, tickerDuration time.Duration, name string, thread int) {
+	tb.Helper()
+
 	tb.Logf("[%s] starting %s", common.NowMilliseconds(), name)
+
 	defer func() {
 		tb.Logf("[%s] stop %s", common.NowMilliseconds(), name)
 	}()
@@ -4418,6 +4443,7 @@ func runWithTicker(tb testing.TB, fn func(c chan struct{}), done chan struct{},
 	select {
 	case <-done:
 		tb.Logf("[%s] Short path. finishing outer runWithTicker for %q, thread %d", common.NowMilliseconds(), name, thread)
+
 		return
 	default:
 	}
@@ -4455,14 +4481,6 @@ func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct
 	default:
 	}
 
-	/*
-		defer func() {
-			tb.Logf("[%s] finishing inner runWithTimeout for %q, thread %d, iteration %d",
-				common.NowMilliseconds(), name, thread, n)
-		}()
-
-	*/
-
 	timeout := time.NewTimer(timeoutDuration)
 	defer timeout.Stop()
 
@@ -4474,23 +4492,12 @@ func runWithTimeout(tb testing.TB, fn func(chan struct{}), outerDone chan struct
 	go func() {
 		defer close(doneCh)
 
-		/*
-			tb.Logf("[%s] starting inner runWithTimeout for %q, timeout in %v, thread %d, iteration %d",
-				common.NowMilliseconds(), name, timeoutDuration, thread, n)
-
-		*/
-
 		select {
 		case <-outerDone:
 			return
 		default:
 			fn(doneCh)
 		}
-
-		/*
-			tb.Logf("[%s] finished inner runWithTimeout for %q, thread %d, iteration %d", common.NowMilliseconds(), name, thread, n)
-
-		*/
 	}()
 
 	const isDebug = false

From b9cedf1f62f15220a598ab15a2d9e250fad9f3c3 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 09:46:35 +0400
Subject: [PATCH 92/96] add statistics

---
 core/tx_pool_test.go | 54 ++++++++++++++++++++++++++++++++++++++------
 1 file changed, 47 insertions(+), 7 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index d99e4c8fde..4cd1320db1 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2803,11 +2803,26 @@ func BenchmarkPoolMining(b *testing.B) {
 			b.ResetTimer()
 			b.ReportAllocs()
 
+			pendingDurations := make([]time.Duration, b.N)
+
+			var added int
+
 			for i := 0; i < b.N; i++ {
-				total += mining(b, pool, signer, baseFee, blockGasLimit, i)
+				added, pendingDurations[i] = mining(b, pool, signer, baseFee, blockGasLimit, i)
+				total += added
 			}
 
 			b.StopTimer()
+
+			pendingDurationsFloat := make([]float64, len(pendingDurations))
+
+			for i, v := range pendingDurations {
+				pendingDurationsFloat[i] = float64(v.Nanoseconds())
+			}
+
+			mean, stddev := stat.MeanStdDev(pendingDurationsFloat, nil)
+			b.Logf("pending mean %v, stdev %v, %v-%v);",
+				time.Duration(mean), time.Duration(stddev), time.Duration(floats.Min(pendingDurationsFloat)), time.Duration(floats.Max(pendingDurationsFloat)))
 		})
 	}
 }
@@ -3672,7 +3687,7 @@ func MakeWithPromoteTxCh(ch chan struct{}) func(*TxPool) {
 }
 
 //nolint:thelper
-func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) int {
+func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) (int, time.Duration) {
 	var (
 		localTxsCount  int
 		remoteTxsCount int
@@ -3681,7 +3696,12 @@ func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.I
 		total          int
 	)
 
+	start := time.Now()
+
 	pending := pool.Pending(context.Background(), true)
+
+	pendingDuration := time.Since(start)
+
 	remoteTxs = pending
 
 	locals := pool.Locals()
@@ -3719,10 +3739,10 @@ func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.I
 		total += txRemoteCount
 	}
 
-	tb.Logf("[%s] mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d, localTxsCount %d, remoteTxsCount %d",
-		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen, localTxsCount, remoteTxsCount)
+	tb.Logf("[%s] mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d, localTxsCount %d, remoteTxsCount %d, pending %v, mining %v",
+		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen, localTxsCount, remoteTxsCount, pendingDuration, time.Since(start))
 
-	return total
+	return total, pendingDuration
 }
 
 //nolint:paralleltest
@@ -4351,16 +4371,36 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	blockTicker := time.NewTicker(blockPeriod)
 	defer blockTicker.Stop()
 
+	pendingDurations := make([]time.Duration, 0, blocks)
+
+	var (
+		added           int
+		pendingDuration time.Duration
+	)
+
 	for range blockTicker.C {
-		totalTxs += mining(tb, pool, signer, baseFee, blockGasLimit, totalBlocks)
+		added, pendingDuration = mining(tb, pool, signer, baseFee, blockGasLimit, totalBlocks)
+
+		totalTxs += added
+		pendingDurations = append(pendingDurations, pendingDuration)
 
 		totalBlocks++
 
 		if totalBlocks > blocks {
 			fmt.Fprint(io.Discard, totalTxs)
-			return
+			break
 		}
 	}
+
+	pendingDurationsFloat := make([]float64, len(pendingDurations))
+
+	for i, v := range pendingDurations {
+		pendingDurationsFloat[i] = float64(v.Nanoseconds())
+	}
+
+	mean, stddev := stat.MeanStdDev(pendingDurationsFloat, nil)
+	tb.Logf("pending mean %v, stddev %v, %v-%v);",
+		time.Duration(mean), time.Duration(stddev), time.Duration(floats.Min(pendingDurationsFloat)), time.Duration(floats.Max(pendingDurationsFloat)))
 }
 
 func addTransactionsBatches(tb testing.TB, batches []types.Transactions, fn func(types.Transactions) error, done chan struct{}, timeoutDuration time.Duration, tickerDuration time.Duration, name string, thread int) {

From ec472dbf2d1a6ad2f8bb2b2e268c9937f2591ee2 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 10:10:46 +0400
Subject: [PATCH 93/96] add statistics

---
 core/tx_pool_test.go | 33 ++++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 13 deletions(-)

diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 4cd1320db1..79e0f509c0 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -2808,7 +2808,7 @@ func BenchmarkPoolMining(b *testing.B) {
 			var added int
 
 			for i := 0; i < b.N; i++ {
-				added, pendingDurations[i] = mining(b, pool, signer, baseFee, blockGasLimit, i)
+				added, pendingDurations[i], _ = mining(b, pool, signer, baseFee, blockGasLimit, i)
 				total += added
 			}
 
@@ -2821,8 +2821,8 @@ func BenchmarkPoolMining(b *testing.B) {
 			}
 
 			mean, stddev := stat.MeanStdDev(pendingDurationsFloat, nil)
-			b.Logf("pending mean %v, stdev %v, %v-%v);",
-				time.Duration(mean), time.Duration(stddev), time.Duration(floats.Min(pendingDurationsFloat)), time.Duration(floats.Max(pendingDurationsFloat)))
+			b.Logf("[%s] pending mean %v, stdev %v, %v-%v",
+				common.NowMilliseconds(), time.Duration(mean), time.Duration(stddev), time.Duration(floats.Min(pendingDurationsFloat)), time.Duration(floats.Max(pendingDurationsFloat)))
 		})
 	}
 }
@@ -3687,7 +3687,7 @@ func MakeWithPromoteTxCh(ch chan struct{}) func(*TxPool) {
 }
 
 //nolint:thelper
-func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) (int, time.Duration) {
+func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.Int, blockGasLimit uint64, totalBlocks int) (int, time.Duration, time.Duration) {
 	var (
 		localTxsCount  int
 		remoteTxsCount int
@@ -3739,10 +3739,12 @@ func mining(tb testing.TB, pool *TxPool, signer types.Signer, baseFee *uint256.I
 		total += txRemoteCount
 	}
 
+	miningDuration := time.Since(start)
+
 	tb.Logf("[%s] mining block. block %d. total %d: pending %d(added %d), local %d(added %d), queued %d, localTxsCount %d, remoteTxsCount %d, pending %v, mining %v",
-		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen, localTxsCount, remoteTxsCount, pendingDuration, time.Since(start))
+		common.NowMilliseconds(), totalBlocks, total, pendingLen, txRemoteCount, localTxsCount, txLocalCount, queuedLen, localTxsCount, remoteTxsCount, pendingDuration, miningDuration)
 
-	return total, pendingDuration
+	return total, pendingDuration, miningDuration
 }
 
 //nolint:paralleltest
@@ -4368,20 +4370,20 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 		totalBlocks int
 	)
 
-	blockTicker := time.NewTicker(blockPeriod)
-	defer blockTicker.Stop()
-
 	pendingDurations := make([]time.Duration, 0, blocks)
 
 	var (
 		added           int
 		pendingDuration time.Duration
+		miningDuration  time.Duration
+		diff            time.Duration
 	)
 
-	for range blockTicker.C {
-		added, pendingDuration = mining(tb, pool, signer, baseFee, blockGasLimit, totalBlocks)
+	for {
+		added, pendingDuration, miningDuration = mining(tb, pool, signer, baseFee, blockGasLimit, totalBlocks)
 
 		totalTxs += added
+
 		pendingDurations = append(pendingDurations, pendingDuration)
 
 		totalBlocks++
@@ -4390,6 +4392,11 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 			fmt.Fprint(io.Discard, totalTxs)
 			break
 		}
+
+		diff = blockPeriod - miningDuration
+		if diff > 0 {
+			time.Sleep(diff)
+		}
 	}
 
 	pendingDurationsFloat := make([]float64, len(pendingDurations))
@@ -4399,8 +4406,8 @@ func apiWithMining(tb testing.TB, balanceStr string, batchesSize int, singleCase
 	}
 
 	mean, stddev := stat.MeanStdDev(pendingDurationsFloat, nil)
-	tb.Logf("pending mean %v, stddev %v, %v-%v);",
-		time.Duration(mean), time.Duration(stddev), time.Duration(floats.Min(pendingDurationsFloat)), time.Duration(floats.Max(pendingDurationsFloat)))
+	tb.Logf("[%s] pending mean %v, stddev %v, %v-%v",
+		common.NowMilliseconds(), time.Duration(mean), time.Duration(stddev), time.Duration(floats.Min(pendingDurationsFloat)), time.Duration(floats.Max(pendingDurationsFloat)))
 }
 
 func addTransactionsBatches(tb testing.TB, batches []types.Transactions, fn func(types.Transactions) error, done chan struct{}, timeoutDuration time.Duration, tickerDuration time.Duration, name string, thread int) {

From 390a04c0febc7b07917277a1606865f39e67ac63 Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 14:23:56 +0400
Subject: [PATCH 94/96] txitems data race

---
 core/tx_list.go | 15 +++++++++++++++
 core/tx_pool.go |  4 ++--
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 518aebea33..6c50b32046 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -80,6 +80,17 @@ func (m *txSortedMap) Get(nonce uint64) *types.Transaction {
 	return m.items[nonce]
 }
 
+func (m *txSortedMap) Has(nonce uint64) bool {
+	if m == nil {
+		return false
+	}
+
+	m.m.RLock()
+	defer m.m.RUnlock()
+
+	return m.items[nonce] == nil
+}
+
 // Put inserts a new transaction into the map, also updating the map's nonce
 // index. If a transaction already exists with the same nonce, it's overwritten.
 func (m *txSortedMap) Put(tx *types.Transaction) {
@@ -557,6 +568,10 @@ func (l *txList) LastElement() *types.Transaction {
 	return l.txs.LastElement()
 }
 
+func (l *txList) Has(nonce uint64) bool {
+	return l != nil && l.txs.items[nonce] != nil
+}
+
 // priceHeap is a heap.Interface implementation over transactions for retrieving
 // price-sorted transactions to discard when the pool fills up. If baseFee is set
 // then the heap is sorted based on the effective tip based on the given base fee.
diff --git a/core/tx_pool.go b/core/tx_pool.go
index ac2f9e11ee..e98fd2e0ae 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -1243,7 +1243,7 @@ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 
 		pool.pendingMu.RLock()
 
-		if txList = pool.pending[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
+		if txList = pool.pending[from]; txList != nil && txList.txs.Has(tx.Nonce()) {
 			status[i] = TxStatusPending
 			isPending = true
 		} else {
@@ -1255,7 +1255,7 @@ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 		if !isPending {
 			pool.mu.RLock()
 
-			if txList := pool.queue[from]; txList != nil && txList.txs.items[tx.Nonce()] != nil {
+			if txList := pool.queue[from]; txList != nil && txList.txs.Has(tx.Nonce()) {
 				status[i] = TxStatusQueued
 			}
 

From 618bcfb2926ea7d08247c7ee300e55eba21119ec Mon Sep 17 00:00:00 2001
From: Evgeny Danienko <6655321@bk.ru>
Date: Sat, 12 Nov 2022 20:44:26 +0400
Subject: [PATCH 95/96] fix tx list Has

---
 core/tx_list.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/tx_list.go b/core/tx_list.go
index 6c50b32046..e763777e33 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -88,7 +88,7 @@ func (m *txSortedMap) Has(nonce uint64) bool {
 	m.m.RLock()
 	defer m.m.RUnlock()
 
-	return m.items[nonce] == nil
+	return m.items[nonce] != nil
 }
 
 // Put inserts a new transaction into the map, also updating the map's nonce

From 0e9f675f256a3f3d65efe66a39f0d21d4ba678f5 Mon Sep 17 00:00:00 2001
From: Shivam Sharma <shivam691999@gmail.com>
Date: Tue, 29 Nov 2022 17:11:17 +0530
Subject: [PATCH 96/96] fix : lint

---
 consensus/misc/eip1559.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/consensus/misc/eip1559.go b/consensus/misc/eip1559.go
index 656af13f2f..00a8ab5b58 100644
--- a/consensus/misc/eip1559.go
+++ b/consensus/misc/eip1559.go
@@ -97,7 +97,6 @@ func CalcBaseFee(config *params.ChainConfig, parent *types.Header) *big.Int {
 
 // CalcBaseFee calculates the basefee of the header.
 func CalcBaseFeeUint(config *params.ChainConfig, parent *types.Header) *uint256.Int {
-
 	var (
 		initialBaseFeeUint             = uint256.NewInt(params.InitialBaseFee)
 		baseFeeChangeDenominatorUint64 = params.BaseFeeChangeDenominator(config.Bor, parent.Number)